From ec836c218f910a56f4249fe0ba689066db99981e Mon Sep 17 00:00:00 2001
From: Tom Scogland <scogland1@llnl.gov>
Date: Thu, 7 Nov 2019 10:38:05 +0000
Subject: [PATCH 01/19] concepts: refactor convertible_to out to is_convertible

This is the beginning of a relatively large concepts/type-traits refactor that is going to come in over the next while. First is factoring out convertible_to so it looks/works more like the standard library version so I can start converting detector into a more user-friendly version we can actually expose.  This is a bug for GEOSX and others, and should also make our type_traits more robust once it's all in.
---
 .gitignore                                  |  3 ++
 include/camp/defines.hpp                    |  3 ++
 include/camp/detail/test.hpp                | 21 ++++++++-
 include/camp/helpers.hpp                    | 51 ++++++++++++---------
 include/camp/type_traits/is_convertible.hpp | 36 +++++++++++++++
 test/CMakeLists.txt                         |  1 +
 test/convertible.cpp                        | 22 +++++++++
 7 files changed, 114 insertions(+), 23 deletions(-)
 create mode 100644 include/camp/type_traits/is_convertible.hpp
 create mode 100644 test/convertible.cpp

diff --git a/.gitignore b/.gitignore
index 4c82b137..63b6d750 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,5 +5,8 @@
 *.gch
 build/
 build-*/
+cmake-build-*
 /Debug/
 ./extern/googletest/*
+.vscode
+.idea
diff --git a/include/camp/defines.hpp b/include/camp/defines.hpp
index 3143209b..7ddcc4d6 100644
--- a/include/camp/defines.hpp
+++ b/include/camp/defines.hpp
@@ -88,6 +88,9 @@ using nullptr_t = decltype(nullptr);
     using type = typename X<Lambda::template expr, Rest...>::type; \
   }
 
+#define CAMP_STRINGIFY_IMPL(x) #x
+#define CAMP_STRINGIFY(x) CAMP_STRINGIFY_IMPL(x)
+#define CAMP_UNQUOTE(...) __VA_ARGS__
 }  // namespace camp
 
 #endif
diff --git a/include/camp/detail/test.hpp b/include/camp/detail/test.hpp
index 3c5cbc78..3f96d51a 100644
--- a/include/camp/detail/test.hpp
+++ b/include/camp/detail/test.hpp
@@ -26,7 +26,6 @@ namespace test
                   "is_same assertion failed <see below for more information>");
     static bool constexpr value = is_same<T1, T2>::value;
   };
-#define CAMP_UNQUOTE(...) __VA_ARGS__
 #define CAMP_CHECK_SAME(X, Y)                                          \
   static_assert(                                                       \
       ::camp::test::AssertSame<CAMP_UNQUOTE X, CAMP_UNQUOTE Y>::value, \
@@ -45,6 +44,26 @@ namespace test
   static_assert(                                                        \
       ::camp::test::AssertValue<CAMP_UNQUOTE X, CAMP_UNQUOTE Y>::value, \
       #X "::value == " #Y)
+template <typename Assertion>
+struct AssertTrue {
+  static_assert(Assertion::value,
+                "value assertion failed <see below for more information>");
+  static bool const value = Assertion::value;
+};
+#define CAMP_CHECK_VALUE(...)                                            \
+  static_assert(                                                        \
+      ::camp::test::AssertTrue<__VA_ARGS__>::value, \
+      "CAMP static assert failed, ::value is not true")
+template <typename Assertion>
+struct AssertFalse {
+  static_assert(!Assertion::value,
+                "value assertion failed <see below for more information>");
+  static bool const value = !Assertion::value;
+};
+#define CAMP_CHECK_VALUE_NOT(...)                                            \
+  static_assert(                                                        \
+      ::camp::test::AssertFalse<__VA_ARGS__>::value, \
+      "CAMP static assert failed, ::value is true")
 }  // namespace test
 #endif  // CAMP_DOX
 ///\endcond
diff --git a/include/camp/helpers.hpp b/include/camp/helpers.hpp
index df355cb5..dec0f3b6 100644
--- a/include/camp/helpers.hpp
+++ b/include/camp/helpers.hpp
@@ -20,28 +20,6 @@ For details about use and distribution, please read LICENSE and NOTICE from
 namespace camp
 {
 
-/// metafunction to get instance of pointer type
-template <typename T>
-T* declptr();
-
-/// metafunction to get instance of value type
-template <typename T>
-auto val() noexcept -> decltype(std::declval<T>());
-
-/// metafunction to get instance of const type
-template <typename T>
-auto cval() noexcept -> decltype(std::declval<T const>());
-
-/// metafunction to expand a parameter pack and ignore result
-template <typename... Ts>
-CAMP_HOST_DEVICE void sink(Ts...)
-{
-}
-
-// bring common utility routines into scope to allow ADL
-using std::begin;
-using std::swap;
-
 namespace type
 {
   namespace ref
@@ -144,6 +122,35 @@ namespace type
   }  // namespace cv
 }  // end namespace type
 
+/// metafunction to get instance of pointer type
+template <typename T>
+T* declptr();
+
+/// metafunction to get instance of value type
+template <typename T>
+type::rvref::add<T> val() noexcept;
+/// metafunction to get instance of value type
+template <typename T>
+type::rvref::add<T> declval() noexcept;
+
+/// metafunction to get instance of const type
+template <typename T>
+auto cval() noexcept -> decltype(declval<T const>());
+
+/// metafunction to expand a parameter pack and ignore result
+template <typename... Ts>
+CAMP_HOST_DEVICE void sink(Ts...)
+{
+}
+
+/// metafunction to return a specific type if arg can be instantiated
+template <typename Ret, typename T>
+Ret returns(T const&) noexcept;
+
+// bring common utility routines into scope to allow ADL
+using std::begin;
+using std::swap;
+
 template <typename T>
 using decay = type::cv::rem<type::ref::rem<T>>;
 
diff --git a/include/camp/type_traits/is_convertible.hpp b/include/camp/type_traits/is_convertible.hpp
new file mode 100644
index 00000000..cb062f48
--- /dev/null
+++ b/include/camp/type_traits/is_convertible.hpp
@@ -0,0 +1,36 @@
+//
+// Created by Tom Scogland on 11/5/19.
+//
+
+#ifndef CAMP_IS_CONVERTIBLE_HPP
+#define CAMP_IS_CONVERTIBLE_HPP
+
+#include "../number/number.hpp"
+#include "../helpers.hpp"
+
+namespace camp
+{
+
+namespace detail
+{
+  template <typename T>
+  constexpr void test_conversion(T &&u) noexcept;
+}
+
+/// type trait to validate T is convertible to U
+template <typename T, typename U, typename V = void>
+struct is_convertible : false_type {
+};
+
+/// type trait to validate T is convertible to U
+template <typename T, typename U>
+struct is_convertible<T, U, decltype(detail::test_conversion<U>(val<T>()))> : true_type {
+};
+
+/// type trait to validate T is convertible to U
+template <typename T, typename U>
+using is_convertible_t = typename is_convertible<T,U>::type;
+
+}  // namespace camp
+
+#endif  // CAMP_IS_CONVERTIBLE_HPP
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 4973ee9a..eb57846c 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -117,6 +117,7 @@ camp_add_test(tuple_out_of_range RUN)
 
 camp_add_test(accumulate)
 camp_add_test(at_key)
+camp_add_test(convertible)
 camp_add_test(filter)
 camp_add_test(find_if)
 camp_add_test(flatten)
diff --git a/test/convertible.cpp b/test/convertible.cpp
new file mode 100644
index 00000000..7d24db0e
--- /dev/null
+++ b/test/convertible.cpp
@@ -0,0 +1,22 @@
+//
+// Created by Tom Scogland on 11/5/19.
+//
+
+#include <camp/detail/test.hpp>
+#include <camp/type_traits/is_convertible.hpp>
+
+using namespace camp;
+
+class A {};
+class B : public A {};
+class C {};
+class D { public: operator C() { return c; }  C c; };
+
+
+CAMP_CHECK_VALUE(is_convertible<B*, A*>);
+CAMP_CHECK_VALUE_NOT(is_convertible<A*, B*>);
+CAMP_CHECK_VALUE_NOT(is_convertible<B*, C*>);
+CAMP_CHECK_VALUE(is_convertible_t<D, C>);
+
+CAMP_CHECK_VALUE(is_convertible<int, int>);
+CAMP_CHECK_VALUE(is_convertible<int, double>);

From d2b86c774db1a287610378f5507691c170315e2f Mon Sep 17 00:00:00 2001
From: Tom Scogland <scogland1@llnl.gov>
Date: Thu, 7 Nov 2019 11:11:35 +0000
Subject: [PATCH 02/19] concepts: refactor detection out into detect.hpp

With the is_convertible changes, this is the basis for the whole
refactor setup.  Concepts will all be defined against the new detector,
as will type traits, using the new idiom through the macro so if we need
to do this again it wont have to touch them all.
---
 include/camp/concepts/detect.hpp            |  94 ++++++++++++++
 include/camp/type_traits/is_convertible.hpp |   9 +-
 test/CMakeLists.txt                         |   1 +
 test/detect.cpp                             | 135 ++++++++++++++++++++
 4 files changed, 235 insertions(+), 4 deletions(-)
 create mode 100644 include/camp/concepts/detect.hpp
 create mode 100644 test/detect.cpp

diff --git a/include/camp/concepts/detect.hpp b/include/camp/concepts/detect.hpp
new file mode 100644
index 00000000..7fdec664
--- /dev/null
+++ b/include/camp/concepts/detect.hpp
@@ -0,0 +1,94 @@
+//
+// Created by Tom Scogland on 11/5/19.
+//
+
+#ifndef CAMP_DETECT_HPP
+#define CAMP_DETECT_HPP
+
+#include "../number/number.hpp"
+#include "../type_traits/is_convertible.hpp"
+#include "../type_traits/is_same.hpp"
+
+namespace camp
+{
+
+namespace detail
+{
+  template <class...>
+  struct void_t {
+    using type = void;
+  };
+
+  struct nonesuch {
+
+    nonesuch() = delete;
+    ~nonesuch() = delete;
+    nonesuch(nonesuch const &) = delete;
+    void operator=(nonesuch const &) = delete;
+  };
+
+  template <class Default,
+            class /* always void*/,
+            template <class...>
+            class Concept,
+            class... Args>
+  struct _detector {
+    using value_t = ::camp::false_type;
+    constexpr static auto value = false;
+    using type = Default;
+  };
+
+  template <class Default, template <class...> class Concept, class... Args>
+  struct _detector<Default,
+                   typename void_t<Concept<Args...>>::type,
+                   Concept,
+                   Args...> {
+    using value_t = ::camp::true_type;
+    constexpr static auto value = true;
+    //    using type = typename Concept<Args...>::type;
+    using type = Concept<Args...>;
+  };
+
+  template <typename... T>
+  camp::true_type ___valid_expr___(T &&...) noexcept;
+}  // namespace detail
+
+template <template <class...> class Op, class... Args>
+using is_detected = detail::_detector<detail::nonesuch, void, Op, Args...>;
+
+template <template <class...> class Op, class... Args>
+using detected_t = typename is_detected<Op, Args...>::type;
+
+template <class Default, template <class...> class Op, class... Args>
+using detected_or = detail::_detector<Default, void, Op, Args...>;
+
+template <class Default, template <class...> class Op, class... Args>
+using detected_or_t = typename detected_or<Default, Op, Args...>::type;
+
+
+template <class Expected, template <class...> class Op, class... Args>
+using is_detected_exact = is_same<Expected, detected_t<Op, Args...>>;
+
+template <class To, template <class...> class Op, class... Args>
+using is_detected_convertible = is_convertible<detected_t<Op, Args...>, To>;
+
+
+#define CAMP_DEF_DETECTOR(name, params, ...)                   \
+  template <CAMP_UNQUOTE params, typename __Res = __VA_ARGS__> \
+  using name = __Res
+
+#define CAMP_DEF_DETECTOR_T(name, ...)                   \
+  template <class T, typename __Res = __VA_ARGS__> \
+  using name = __Res
+
+#define CAMP_DEF_DETECTOR_TU(name, ...)                   \
+  template <class T, class U, typename __Res = __VA_ARGS__> \
+  using name = __Res
+
+#define CAMP_DEF_CONCEPT(name, params, ...) \
+  CAMP_DEF_DETECTOR(name,                   \
+                    params,                 \
+                    decltype(detail::___valid_expr___(__VA_ARGS__)))
+
+}  // namespace camp
+#endif  // CAMP_DETECT_HPP
diff --git a/include/camp/type_traits/is_convertible.hpp b/include/camp/type_traits/is_convertible.hpp
index cb062f48..c9fe1f1d 100644
--- a/include/camp/type_traits/is_convertible.hpp
+++ b/include/camp/type_traits/is_convertible.hpp
@@ -13,8 +13,9 @@ namespace camp
 
 namespace detail
 {
-  template <typename T>
-  constexpr void test_conversion(T &&u) noexcept;
+  template <typename TO>
+  constexpr void test_conversion(TO) noexcept;
+
 }
 
 /// type trait to validate T is convertible to U
@@ -23,8 +24,8 @@ struct is_convertible : false_type {
 };
 
 /// type trait to validate T is convertible to U
-template <typename T, typename U>
-struct is_convertible<T, U, decltype(detail::test_conversion<U>(val<T>()))> : true_type {
+template <typename FROM, typename TO>
+struct is_convertible<FROM, TO, decltype(detail::test_conversion<TO>(val<FROM>()))> : true_type {
 };
 
 /// type trait to validate T is convertible to U
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index eb57846c..14e599d9 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -118,6 +118,7 @@ camp_add_test(tuple_out_of_range RUN)
 camp_add_test(accumulate)
 camp_add_test(at_key)
 camp_add_test(convertible)
+camp_add_test(detect)
 camp_add_test(filter)
 camp_add_test(find_if)
 camp_add_test(flatten)
diff --git a/test/detect.cpp b/test/detect.cpp
new file mode 100644
index 00000000..32c837e6
--- /dev/null
+++ b/test/detect.cpp
@@ -0,0 +1,135 @@
+//
+// Created by Tom Scogland on 11/5/19.
+//
+
+#include <camp/concepts/detect.hpp>
+#include <camp/detail/test.hpp>
+#include <camp/helpers.hpp>
+#include <camp/list.hpp>
+
+using namespace camp;
+
+struct A {
+};
+struct B : A {
+};
+struct C {
+};
+template <int I>
+struct D : A {
+};
+
+struct TC1 {
+  using my_member_type = C;
+
+  static constexpr auto my_static_data_member = int(42);
+
+  void my_method();
+
+  int my_int_method(double, float);
+
+  double my_method_with_overloads();
+
+  B& my_method_with_overloads(my_member_type);
+
+  void my_method_with_overloads(int**);
+
+  my_member_type my_method_with_overloads(my_member_type, double);
+
+  TC1& my_method_with_overloads(A const&);
+};
+
+// TODO test these in other scopes that could trip up compilers, like function
+// scope or dependent class template scope
+
+CAMP_DEF_DETECTOR(_my_member_type_missing,
+                  (class T),
+                  typename T::my_member_type_missing);
+
+CAMP_CHECK_VALUE_NOT(is_detected<_my_member_type_missing, TC1>);
+
+// tests courtesy of Kokkos and David Hollman
+//  template <class T>
+//  using _my_member_type_archetype = typename T::my_member_type;
+CAMP_DEF_DETECTOR_T(_my_member_type_archetype, typename T::my_member_type);
+
+CAMP_CHECK_VALUE(is_detected<_my_member_type_archetype, TC1>);
+
+CAMP_CHECK_VALUE(is_detected_exact<C, _my_member_type_archetype, TC1>);
+
+CAMP_CHECK_VALUE(is_detected_convertible<C, _my_member_type_archetype, TC1>);
+
+
+CAMP_DEF_DETECTOR_T(_my_method_archetype_1, decltype(T{}.my_method()));
+
+CAMP_DEF_DETECTOR_T(_my_method_archetype_2, decltype(declval<T>().my_method()));
+
+CAMP_CHECK_VALUE(is_detected<_my_method_archetype_1, TC1>);
+
+CAMP_CHECK_VALUE(is_detected<_my_method_archetype_2, TC1>);
+
+CAMP_CHECK_VALUE(is_detected_exact<void, _my_method_archetype_1, TC1>);
+
+CAMP_CHECK_VALUE(is_detected_exact<void, _my_method_archetype_2, TC1>);
+
+template <class Tin>
+struct OuterClass {
+  // Things like this don't work with intel or cuda (probably a bug in the EDG
+  // frontend)
+
+  CAMP_DEF_DETECTOR_T(
+      _inner_method_archetype,
+      decltype(declval<T>().my_method_with_overloads(declval<Tin>())));
+
+  CAMP_DEF_DETECTOR_TU(
+      _inner_method_reversed_archetype_protected,
+      decltype(declval<U>().my_method_with_overloads(declval<T>())));
+
+  template <class T>
+  struct _inner_method_reversed_archetype
+      : detected_t<_inner_method_reversed_archetype_protected, T, Tin> {
+  };
+
+  // test the compiler's ability to handle indirection with this pattern
+  // Should be the last overload when T = TC1 and Tin = C
+  // (since the detected argument type should resolve to the second overload,
+  //   which returns B&), and not detected otherwise
+  CAMP_DEF_DETECTOR_T(_overload_nested_dependent_type_archetype,
+                      decltype(declval<T>().my_method_with_overloads(
+                          declval<detected_t<_inner_method_archetype, T>>())));
+};
+
+// Should be the third overload
+CAMP_CHECK_VALUE(
+    is_detected<OuterClass<int**>::template _inner_method_archetype, TC1>);
+CAMP_CHECK_VALUE_NOT(
+    is_detected<OuterClass<int>::template _inner_method_archetype, TC1>);
+
+CAMP_CHECK_VALUE(
+    std::is_same<
+        void,
+        detected_t<OuterClass<int**>::template _inner_method_archetype, TC1>>);
+
+using OCL = OuterClass<list<std::integral_constant<int, 5>>>;
+
+CAMP_CHECK_VALUE_NOT(is_detected_convertible<
+                     TC1,
+                     OCL::template _overload_nested_dependent_type_archetype,
+                     TC1>);
+
+CAMP_CHECK_VALUE_NOT(
+    is_detected<OCL::template _overload_nested_dependent_type_archetype, TC1>);
+
+// The hardest test: should be the last overload
+CAMP_CHECK_VALUE(
+    is_detected<
+        OuterClass<C>::template _overload_nested_dependent_type_archetype,
+        TC1>);
+
+CAMP_CHECK_VALUE(is_convertible<TC1, TC1>);
+
+CAMP_CHECK_VALUE(
+    is_detected_convertible<
+        TC1,
+        OuterClass<C>::template _overload_nested_dependent_type_archetype,
+        TC1>);

From 124fe8c65325cf57492336d4d716aab29cb0dafb Mon Sep 17 00:00:00 2001
From: Tom Scogland <scogland1@llnl.gov>
Date: Thu, 7 Nov 2019 11:24:18 +0000
Subject: [PATCH 03/19] add test.runner target

---
 test/CMakeLists.txt | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 14e599d9..e595a6e2 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -111,6 +111,11 @@ endfunction()
 if(ENABLE_CUDA)
   camp_add_test(resource GTEST)
 endif()
+
+add_custom_target(test.runner
+        COMMAND ${CMAKE_COMMAND} --build . --target test --config ${CMAKE_BUILD_TYPE}
+        WORKING_DIRECTORY ${CURRENT_BINARY_DIR}
+        )
 camp_add_test(tuple GTEST)
 
 camp_add_test(tuple_out_of_range RUN)

From f70a876e84b2e65fa84d8eb2a12488f9e10a9d7f Mon Sep 17 00:00:00 2001
From: Tom Scogland <scogland1@llnl.gov>
Date: Fri, 8 Nov 2019 10:40:44 +0000
Subject: [PATCH 04/19] incorporate full detector tests

tests integrated, and some concepts ported, more to go
---
 include/camp/concepts.hpp                     | 97 ++++++-------------
 .../camp/{concepts => type_traits}/detect.hpp | 28 ++++--
 test/CMakeLists.txt                           |  2 +-
 test/detect.cpp                               |  2 +-
 4 files changed, 48 insertions(+), 81 deletions(-)
 rename include/camp/{concepts => type_traits}/detect.hpp (79%)

diff --git a/include/camp/concepts.hpp b/include/camp/concepts.hpp
index e81852db..292c9772 100644
--- a/include/camp/concepts.hpp
+++ b/include/camp/concepts.hpp
@@ -14,11 +14,12 @@ For details about use and distribution, please read LICENSE and NOTICE from
 #include <iterator>
 #include <type_traits>
 
-#include "camp/helpers.hpp"
-#include "camp/list.hpp"
-#include "camp/number.hpp"
+#include "helpers.hpp"
+#include "list.hpp"
+#include "number.hpp"
 
-#include "camp/type_traits/is_same.hpp"
+#include "type_traits/detect.hpp"
+#include "type_traits/is_same.hpp"
 
 namespace camp
 {
@@ -86,41 +87,6 @@ namespace concepts
 
   namespace detail
   {
-
-    template <class...>
-    struct TL {
-    };
-
-    template <class...>
-    struct voider {
-      using type = void;
-    };
-
-    template <class Default,
-              class /* always void*/,
-              template <class...> class Concept,
-              class TArgs>
-    struct detector {
-      using value_t = false_type;
-      using type = Default;
-    };
-
-    template <class Default, template <class...> class Concept, class... Args>
-    struct detector<Default,
-                    typename voider<Concept<Args...>>::type,
-                    Concept,
-                    TL<Args...>> {
-      using value_t = true_type;
-      using type = Concept<Args...>;
-    };
-
-    template <template <class...> class Concept, class TArgs>
-    using is_detected = detector<void, void, Concept, TArgs>;
-
-    template <template <class...> class Concept, class TArgs>
-    using detected = typename is_detected<Concept, TArgs>::value_t;
-
-
     template <typename Ret, typename T>
     Ret returns(T const &) noexcept;
 
@@ -169,37 +135,25 @@ namespace concepts
 
   /// SFINAE concept checking
   template <template <class...> class Op, class... Args>
-  struct requires_ : detail::detected<Op, detail::TL<Args...>> {
+  struct requires_ : is_detected<Op, Args...> {
   };
 
-  template <typename T>
-  struct Swappable : DefineConcept(swap(val<T>(), val<T>())) {
-  };
+  CAMP_DEF_CONCEPT_T(Swappable, swap(val<T>(), val<T>()));
 
-  template <typename T>
-  struct LessThanComparable
-      : DefineConcept(convertible_to<bool>(val<T>() < val<T>())) {
-  };
+  CAMP_DEF_CONCEPT_T(LessThanComparable,
+                     convertible_to<bool>(val<T>() < val<T>()));
 
-  template <typename T>
-  struct GreaterThanComparable
-      : DefineConcept(convertible_to<bool>(val<T>() > val<T>())) {
-  };
+  CAMP_DEF_CONCEPT_T(GreaterThanComparable,
+                     convertible_to<bool>(val<T>() > val<T>()));
 
-  template <typename T>
-  struct LessEqualComparable
-      : DefineConcept(convertible_to<bool>(val<T>() <= val<T>())) {
-  };
+  CAMP_DEF_CONCEPT_T(LessEqualComparable,
+                     convertible_to<bool>(val<T>() <= val<T>()));
 
-  template <typename T>
-  struct GreaterEqualComparable
-      : DefineConcept(convertible_to<bool>(val<T>() >= val<T>())) {
-  };
+  CAMP_DEF_CONCEPT_T(GreaterEqualComparable,
+                     convertible_to<bool>(val<T>() >= val<T>()));
 
-  template <typename T>
-  struct EqualityComparable
-      : DefineConcept(convertible_to<bool>(val<T>() == val<T>())) {
-  };
+  CAMP_DEF_CONCEPT_T(EqualityComparable,
+                     convertible_to<bool>(val<T>() == val<T>()));
 
   template <typename T, typename U>
   struct ComparableTo
@@ -341,21 +295,23 @@ namespace type_traits
     };
 
     template <template <typename...> class Template, typename... T>
-    struct IsSpecialized<typename concepts::detail::voider<decltype(
-                             camp::val<Template<T...>>())>::type,
-                         Template,
-                         T...> : camp::true_type {
+    struct IsSpecialized<
+        typename void_t<decltype(camp::val<Template<T...>>())>::type,
+        Template,
+        T...> : camp::true_type {
     };
 
     template <template <class...> class,
-              template <class...> class,
+              template <class...>
+              class,
               bool,
               class...>
     struct SpecializationOf : camp::false_type {
     };
 
     template <template <class...> class Expected,
-              template <class...> class Actual,
+              template <class...>
+              class Actual,
               class... Args>
     struct SpecializationOf<Expected, Actual, true, Args...>
         : camp::concepts::metalib::is_same<Expected<Args...>, Actual<Args...>> {
@@ -373,7 +329,8 @@ namespace type_traits
   };
 
   template <template <class...> class Expected,
-            template <class...> class Actual,
+            template <class...>
+            class Actual,
             class... Args>
   struct SpecializationOf<Expected, Actual<Args...>>
       : detail::SpecializationOf<Expected,
diff --git a/include/camp/concepts/detect.hpp b/include/camp/type_traits/detect.hpp
similarity index 79%
rename from include/camp/concepts/detect.hpp
rename to include/camp/type_traits/detect.hpp
index 7fdec664..67e68b85 100644
--- a/include/camp/concepts/detect.hpp
+++ b/include/camp/type_traits/detect.hpp
@@ -6,18 +6,20 @@
 #define CAMP_DETECT_HPP
 
 #include "../number/number.hpp"
-#include "../type_traits/is_convertible.hpp"
-#include "../type_traits/is_same.hpp"
+#include "is_convertible.hpp"
+#include "is_same.hpp"
 
 namespace camp
 {
 
+/// meta-type that always produces void
+template <class...>
+struct void_t {
+  using type = void;
+};
+
 namespace detail
 {
-  template <class...>
-  struct void_t {
-    using type = void;
-  };
 
   struct nonesuch {
 
@@ -53,6 +55,8 @@ namespace detail
   camp::true_type ___valid_expr___(T &&...) noexcept;
 }  // namespace detail
 
+/// Detect whether a given template/alias Op can be expanded to a valid type
+/// expression with Args...
 template <template <class...> class Op, class... Args>
 using is_detected = detail::_detector<detail::nonesuch, void, Op, Args...>;
 
@@ -77,18 +81,24 @@ using is_detected_convertible = is_convertible<detected_t<Op, Args...>, To>;
   template <CAMP_UNQUOTE params, typename __Res = __VA_ARGS__> \
   using name = __Res
 
-#define CAMP_DEF_DETECTOR_T(name, ...)                   \
+#define CAMP_DEF_DETECTOR_T(name, ...)             \
   template <class T, typename __Res = __VA_ARGS__> \
   using name = __Res
 
-#define CAMP_DEF_DETECTOR_TU(name, ...)                   \
+#define CAMP_DEF_DETECTOR_TU(name, ...)                     \
   template <class T, class U, typename __Res = __VA_ARGS__> \
   using name = __Res
 
 #define CAMP_DEF_CONCEPT(name, params, ...) \
   CAMP_DEF_DETECTOR(name,                   \
                     params,                 \
-                    decltype(detail::___valid_expr___(__VA_ARGS__)))
+                    decltype(::camp::detail::___valid_expr___(__VA_ARGS__)))
+
+#define CAMP_DEF_CONCEPT_T(name, ...) \
+  CAMP_DEF_CONCEPT(name, (class T), __VA_ARGS__)
+
+#define CAMP_DEF_CONCEPT_TU(name, ...) \
+  CAMP_DEF_CONCEPT(name, (class T, class U), __VA_ARGS__)
 
 }  // namespace camp
 #endif  // CAMP_DETECT_HPP
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index e595a6e2..a8c992ef 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -42,7 +42,7 @@ function(camp_add_test TESTNAME)
     # Actual build setup, do not build by default
     add_executable(${TESTNAME} EXCLUDE_FROM_ALL ${ABT_BUILD})
     add_custom_target(${TESTNAME}.runner
-      COMMAND ${CMAKE_COMMAND} --build . --target ${TESTNAME} --config ${CMAKE_BUILD_TYPE}
+      COMMAND ${CMAKE_COMMAND} --build . -j ${CMAKE_BUILD_PARALLEL_LEVEL} --target ${TESTNAME} --config ${CMAKE_BUILD_TYPE}
       COMMAND "$<TARGET_FILE:${TESTNAME}>"
       WORKING_DIRECTORY ${CURRENT_BINARY_DIR}
       )
diff --git a/test/detect.cpp b/test/detect.cpp
index 32c837e6..26eba10e 100644
--- a/test/detect.cpp
+++ b/test/detect.cpp
@@ -2,10 +2,10 @@
 // Created by Tom Scogland on 11/5/19.
 //
 
-#include <camp/concepts/detect.hpp>
 #include <camp/detail/test.hpp>
 #include <camp/helpers.hpp>
 #include <camp/list.hpp>
+#include <camp/type_traits/detect.hpp>
 
 using namespace camp;
 

From 1556f42cfee12bd413e309381a022cae3dff7b8d Mon Sep 17 00:00:00 2001
From: Tom Scogland <scogland1@llnl.gov>
Date: Fri, 8 Nov 2019 02:50:25 -0800
Subject: [PATCH 05/19] remove parallel passthrough argument from cmake runner

---
 test/CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index a8c992ef..e595a6e2 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -42,7 +42,7 @@ function(camp_add_test TESTNAME)
     # Actual build setup, do not build by default
     add_executable(${TESTNAME} EXCLUDE_FROM_ALL ${ABT_BUILD})
     add_custom_target(${TESTNAME}.runner
-      COMMAND ${CMAKE_COMMAND} --build . -j ${CMAKE_BUILD_PARALLEL_LEVEL} --target ${TESTNAME} --config ${CMAKE_BUILD_TYPE}
+      COMMAND ${CMAKE_COMMAND} --build . --target ${TESTNAME} --config ${CMAKE_BUILD_TYPE}
       COMMAND "$<TARGET_FILE:${TESTNAME}>"
       WORKING_DIRECTORY ${CURRENT_BINARY_DIR}
       )

From fbf97a0c88b652dd68c0d5e5205e0eeff193211c Mon Sep 17 00:00:00 2001
From: Tom Scogland <scogland1@llnl.gov>
Date: Thu, 14 Nov 2019 14:29:35 -0800
Subject: [PATCH 06/19] major concept refactor, they all work now

concepts are working again, and actually have tests in detect.cpp, there
are new macros for defining detectors, requirements (helper for
detectors), concepts, and all-in-one doing a concept and associated
traits.  It's possible there are breaking changes in here if anyone
external is relying on the concepts, but since many of them were broken
I'm hoping this will be a net benefit.
---
 include/camp/camp.hpp               |   1 -
 include/camp/concepts.hpp           | 321 +++++++++++++++-------------
 include/camp/defines.hpp            |  11 +-
 include/camp/helpers.hpp            |  18 +-
 include/camp/type_traits/detect.hpp |  82 ++++++-
 test/detect.cpp                     |  56 ++++-
 6 files changed, 327 insertions(+), 162 deletions(-)

diff --git a/include/camp/camp.hpp b/include/camp/camp.hpp
index 1ad0e878..1c7ab9c4 100644
--- a/include/camp/camp.hpp
+++ b/include/camp/camp.hpp
@@ -11,7 +11,6 @@ For details about use and distribution, please read LICENSE and NOTICE from
 #ifndef __CAMP_HPP
 #define __CAMP_HPP
 
-#include <array>
 #include <type_traits>
 
 #include "camp/defines.hpp"
diff --git a/include/camp/concepts.hpp b/include/camp/concepts.hpp
index 292c9772..19ef67f2 100644
--- a/include/camp/concepts.hpp
+++ b/include/camp/concepts.hpp
@@ -19,6 +19,7 @@ For details about use and distribution, please read LICENSE and NOTICE from
 #include "number.hpp"
 
 #include "type_traits/detect.hpp"
+#include "type_traits/enable_if.hpp"
 #include "type_traits/is_same.hpp"
 
 namespace camp
@@ -72,13 +73,11 @@ namespace concepts
 }  // end namespace concepts
 }  // end namespace camp
 
-template <typename... T>
-camp::true_type ___valid_expr___(T &&...) noexcept;
-#define DefineConcept(...) decltype(___valid_expr___(__VA_ARGS__))
+#define DefineConcept(...) decltype((__VA_ARGS__, true_type()))
 
-#define DefineTypeTraitFromConcept(TTName, ConceptName)             \
-  template <typename... Args>                                       \
-  struct TTName : camp::concepts::requires_<ConceptName, Args...> { \
+#define DefineTypeTraitFromConcept(TTName, ConceptName)       \
+  template <typename... Args>                                 \
+  struct TTName : ::camp::is_detected<ConceptName, Args...> { \
   }
 namespace camp
 {
@@ -108,11 +107,16 @@ namespace concepts
 
   template <typename BoolLike>
   constexpr auto is(BoolLike) noexcept
-      -> camp::if_<BoolLike, camp::true_type, camp::false_type>;
+      -> camp::enable_if_t<BoolLike::value, true_type>
+  {
+    return {};
+  }
 
-  template <typename BoolLike>
-  constexpr auto is_not(BoolLike) noexcept
-      -> camp::if_c<!BoolLike::value, camp::true_type, camp::false_type>;
+  template <typename BoolLike, camp::enable_if_t<!BoolLike::value, int> = 0>
+  constexpr true_type is_not(BoolLike) noexcept
+  {
+    return {};
+  }
 
   /// metaprogramming concept for SFINAE checking of aggregating concepts
   template <typename... Args>
@@ -129,156 +133,187 @@ namespace concepts
   struct any_of : metalib::any_of_t<Args...> {
   };
 
-  /// SFINAE multiple type traits
-  template <typename... Args>
-  using enable_if = typename std::enable_if<all_of<Args...>::value, void>::type;
-
   /// SFINAE concept checking
   template <template <class...> class Op, class... Args>
   struct requires_ : is_detected<Op, Args...> {
   };
 
-  CAMP_DEF_CONCEPT_T(Swappable, swap(val<T>(), val<T>()));
-
-  CAMP_DEF_CONCEPT_T(LessThanComparable,
-                     convertible_to<bool>(val<T>() < val<T>()));
-
-  CAMP_DEF_CONCEPT_T(GreaterThanComparable,
-                     convertible_to<bool>(val<T>() > val<T>()));
-
-  CAMP_DEF_CONCEPT_T(LessEqualComparable,
-                     convertible_to<bool>(val<T>() <= val<T>()));
-
-  CAMP_DEF_CONCEPT_T(GreaterEqualComparable,
-                     convertible_to<bool>(val<T>() >= val<T>()));
-
-  CAMP_DEF_CONCEPT_T(EqualityComparable,
-                     convertible_to<bool>(val<T>() == val<T>()));
-
-  template <typename T, typename U>
-  struct ComparableTo
-      : DefineConcept(convertible_to<bool>(val<U>() < val<T>()),
-                      convertible_to<bool>(val<T>() < val<U>()),
-                      convertible_to<bool>(val<U>() <= val<T>()),
-                      convertible_to<bool>(val<T>() <= val<U>()),
-                      convertible_to<bool>(val<U>() > val<T>()),
-                      convertible_to<bool>(val<T>() > val<U>()),
-                      convertible_to<bool>(val<U>() >= val<T>()),
-                      convertible_to<bool>(val<T>() >= val<U>()),
-                      convertible_to<bool>(val<U>() == val<T>()),
-                      convertible_to<bool>(val<T>() == val<U>()),
-                      convertible_to<bool>(val<U>() != val<T>()),
-                      convertible_to<bool>(val<T>() != val<U>())) {
+  // TODO: add a proper ranges-style swap and update this
+  CAMP_DEF_REQUIREMENT_T(Swappable, swap(val<T>(), val<T>()));
+
+  CAMP_DEF_REQUIREMENT_TU(LessThan, val<T>() < val<U>());
+  CAMP_DEF_REQUIREMENT_TU(GreaterThan, val<T>() > val<U>());
+  CAMP_DEF_REQUIREMENT_TU(LessEqual, val<T>() <= val<U>());
+  CAMP_DEF_REQUIREMENT_TU(GreaterEqual, val<T>() >= val<U>());
+
+  CAMP_DEF_REQUIREMENT_TU(Equality, val<T>() == val<U>());
+  CAMP_DEF_REQUIREMENT_TU(Inequality, val<T>() != val<U>());
+
+  CAMP_DEF_CONCEPT_TU(__Weakly_equality_comparable_with,
+                      (detect_convertible<bool, Equality, T, U>()
+                       && detect_convertible<bool, Inequality, T, U>()
+                       && detect_convertible<bool, Equality, U, T>()
+                       && detect_convertible<bool, Inequality, U, T>()));
+
+  CAMP_DEF_CONCEPT_AND_TRAITS_T(equality_comparable,
+                                is_equality_comparable,
+                                CAMP_REQ(__Weakly_equality_comparable_with,
+                                         T,
+                                         T));
+
+  CAMP_DEF_CONCEPT_AND_TRAITS_TU(
+      equality_comparable_with,
+      is_equality_comparable_with,
+      CAMP_REQ(equality_comparable, T) && CAMP_REQ(equality_comparable, U)
+          && CAMP_REQ(__Weakly_equality_comparable_with, T, U));
+
+  CAMP_DEF_CONCEPT_AND_TRAITS_TU(
+      comparable_with,
+      is_comparable_with,
+      CAMP_REQ(equality_comparable_with, T, U)
+          && detect_convertible<bool, LessThan, T, U>()
+          && detect_convertible<bool, GreaterThan, T, U>()
+          && detect_convertible<bool, LessEqual, T, U>()
+          && detect_convertible<bool, GreaterEqual, T, U>()
+          && detect_convertible<bool, LessThan, U, T>()
+          && detect_convertible<bool, GreaterThan, U, T>()
+          && detect_convertible<bool, LessEqual, U, T>()
+          && detect_convertible<bool, GreaterEqual, U, T>());
+
+  CAMP_DEF_CONCEPT_AND_TRAITS_T(comparable,
+                                is_comparable,
+                                CAMP_REQ(comparable_with, T, T));
+
+  CAMP_DEF_CONCEPT_AND_TRAITS_T(arithmetic,
+                                is_arithmetic,
+                                std::is_arithmetic<T>::value);
+  CAMP_DEF_CONCEPT_AND_TRAITS_T(floating_point,
+                                is_floating_point,
+                                std::is_floating_point<T>::value);
+  CAMP_DEF_CONCEPT_AND_TRAITS_T(integral,
+                                is_integral,
+                                std::is_integral<T>::value);
+  CAMP_DEF_CONCEPT_AND_TRAITS_T(signed, is_signed, std::is_signed<T>::value);
+  CAMP_DEF_CONCEPT_AND_TRAITS_T(unsigned,
+                                is_unsigned,
+                                std::is_unsigned<T>::value);
+
+  CAMP_DEF_REQUIREMENT_T(Dereference, *(val<T>()));
+  CAMP_DEF_REQUIREMENT_T(IncrementPre, ++val<T>());
+  CAMP_DEF_CONCEPT_AND_TRAITS_T(iterator,
+                                is_iterator,
+                                detect<Dereference, T>()
+                                    && detect_exact<T &, IncrementPre, T &>());
+
+  CAMP_DEF_REQUIREMENT_T(IncrementPost, val<T>()++);
+  CAMP_DEF_REQUIREMENT_T(DereferenceIncrementPost, *val<T>()++);
+  CAMP_DEF_CONCEPT_AND_TRAITS_T(forward_iterator,
+                                is_forward_iterator,
+                                CAMP_REQ(iterator, T)
+                                    && detect<IncrementPost, T &>()
+                                    && detect<DereferenceIncrementPost, T &>());
+
+  CAMP_DEF_REQUIREMENT_T(DecrementPre, --val<T>());
+  CAMP_DEF_REQUIREMENT_T(DecrementPost, val<T>()--);
+  CAMP_DEF_REQUIREMENT_T(DereferenceDecrementPost, *val<T>()--);
+  CAMP_DEF_CONCEPT_AND_TRAITS_T(
+      bidirectional_iterator,
+      is_bidirectional_iterator,
+      CAMP_REQ(forward_iterator, T) && detect_exact<T &, DecrementPre, T &>()
+          && detect_convertible<T const &, DecrementPost, T &>()
+          && detect<DereferenceDecrementPost, T &>());
+
+  CAMP_DEF_REQUIREMENT_T(MemberDifferenceType, T::difference_type);
+  CAMP_DEF_REQUIREMENT_TU(PlusEq, val<T>() += val<U>());
+  CAMP_DEF_REQUIREMENT_TU(Plus, val<T>() + val<U>());
+  CAMP_DEF_REQUIREMENT_TU(SubEq, val<T>() -= val<U>());
+  CAMP_DEF_REQUIREMENT_TU(Sub, val<T>() - val<U>());
+  CAMP_DEF_REQUIREMENT_TU(Index, val<T>()[val<U>()]);
+  template <class I, typename = void>
+  struct incrementable_traits {
   };
-
-  template <typename T>
-  struct Comparable : ComparableTo<T, T> {
+  template <class T>
+  struct incrementable_traits<T *, enable_if_t<std::is_object<T>::value>> {
+    using difference_type = ptrdiff_t;
   };
-
-  template <typename T>
-  struct Arithmetic : DefineConcept(is(std::is_arithmetic<T>())) {
+  template <class T>
+  struct incrementable_traits<const T> : incrementable_traits<T> {
   };
-
-  template <typename T>
-  struct FloatingPoint : DefineConcept(is(std::is_floating_point<T>())) {
+  template <class T>
+  struct incrementable_traits<
+      T,
+      enable_if_t<detect<MemberDifferenceType, T>(), void>> {
+    using difference_type = typename T::difference_type;
   };
-
-  template <typename T>
-  struct Integral : DefineConcept(is(std::is_integral<T>())) {
-  };
-
-  template <typename T>
-  struct Signed : DefineConcept(Integral<T>(), is(std::is_signed<T>())) {
+  template <class T>
+  struct incrementable_traits<
+      T,
+      enable_if_t<(!std::is_pointer<T>::value)
+                      && (!detect<MemberDifferenceType, T>())
+                      && detect_convertible<ptrdiff_t, Sub, T, T>(),
+                  void>> {
+    using difference_type = decltype(val<plain<T>>() - val<plain<T>>());
   };
-
   template <typename T>
-  struct Unsigned : DefineConcept(Integral<T>(), is(std::is_unsigned<T>())) {
-  };
+  using difft_from = typename incrementable_traits<T>::difference_type;
+
+  CAMP_DEF_REQUIREMENT_T(ItPlusEqDiff, val<T>() += val<difft_from<T>>());
+  CAMP_DEF_REQUIREMENT_T(ItPlusDiff, val<T>() + val<difft_from<T>>());
+  CAMP_DEF_REQUIREMENT_T(DiffPlusIt, val<difft_from<T>>() + val<T>());
+  CAMP_DEF_REQUIREMENT_T(ItSubEqDiff, val<T>() -= val<difft_from<T>>());
+  CAMP_DEF_REQUIREMENT_T(ItSubDiff, val<T>() - val<difft_from<T>>());
+  CAMP_DEF_REQUIREMENT_T(DiffSubIt, val<difft_from<T>>() - val<T>());
+  CAMP_DEF_REQUIREMENT_T(IndexDiff, val<T>()[val<difft_from<T>>()]);
+
+  CAMP_DEF_CONCEPT_AND_TRAITS_T(random_access_iterator,
+                                is_random_access_iterator,
+                                CAMP_REQ(bidirectional_iterator, T)
+                                    && CAMP_REQ(comparable, T)
+                                    && detect_exact<T &, ItPlusEqDiff, T &>()
+                                    && detect_exact<T, ItPlusDiff, T>()
+                                    && detect_exact<T, DiffPlusIt, T>()
+                                    && detect_exact<T &, ItSubEqDiff, T &>()
+                                    && detect_exact<T, ItSubDiff, T>()
+                                    && detect<IndexDiff, T>());
+
+  CAMP_DEF_REQUIREMENT_T(BeginMember, val<T>().begin());
+  CAMP_DEF_REQUIREMENT_T(BeginFree, begin(val<T>()));
+  CAMP_DEF_REQUIREMENT_T(EndMember, val<T>().end());
+  CAMP_DEF_REQUIREMENT_T(EndFree, end(val<T>()));
+  CAMP_DEF_CONCEPT_AND_TRAITS_T(
+      has_begin_end,
+      trait_has_begin_end,
+      (detect<BeginMember, T>() || detect<BeginFree>())
+          && (detect<EndMember, T>() || detect<EndFree>()));
+
+  // template <typename T>
+  // struct Range : DefineConcept(HasBeginEnd<T>(),
+  // Iterator<iterator_from<T>>()) {
+  // };
+  //
+  // template <typename T>
+  // struct ForwardRange
+  //     : DefineConcept(HasBeginEnd<T>(), ForwardIterator<iterator_from<T>>())
+  //     {
+  // };
+  //
+  // template <typename T>
+  // struct BidirectionalRange
+  //     : DefineConcept(HasBeginEnd<T>(),
+  //                     BidirectionalIterator<iterator_from<T>>()) {
+  // };
+
+  CAMP_DEF_CONCEPT_AND_TRAITS_T(random_access_range,
+                                is_random_access_range,
+                                CAMP_REQ(has_begin_end, T)
+                                    && CAMP_REQ(random_access_iterator,
+                                                iterator_from<T>));
 
-  template <typename T>
-  struct Iterator
-      : DefineConcept(is_not(Integral<T>()),  // hacky NVCC 8 workaround
-                      *(val<T>()),
-                      has_type<T &>(++val<T &>())) {
-  };
-
-  template <typename T>
-  struct ForwardIterator
-      : DefineConcept(Iterator<T>(), val<T &>()++, *val<T &>()++) {
-  };
-
-  template <typename T>
-  struct BidirectionalIterator
-      : DefineConcept(ForwardIterator<T>(),
-                      has_type<T &>(--val<T &>()),
-                      convertible_to<T const &>(val<T &>()--),
-                      *val<T &>()--) {
-  };
-
-  template <typename T>
-  struct RandomAccessIterator
-      : DefineConcept(BidirectionalIterator<T>(),
-                      Comparable<T>(),
-                      has_type<T &>(val<T &>() += val<diff_from<T>>()),
-                      has_type<T>(val<T>() + val<diff_from<T>>()),
-                      has_type<T>(val<diff_from<T>>() + val<T>()),
-                      has_type<T &>(val<T &>() -= val<diff_from<T>>()),
-                      has_type<T>(val<T>() - val<diff_from<T>>()),
-                      val<T>()[val<diff_from<T>>()]) {
-  };
-
-  template <typename T>
-  struct HasBeginEnd : DefineConcept(std::begin(val<T>()), std::end(val<T>())) {
-  };
-
-  template <typename T>
-  struct Range : DefineConcept(HasBeginEnd<T>(), Iterator<iterator_from<T>>()) {
-  };
-
-  template <typename T>
-  struct ForwardRange
-      : DefineConcept(HasBeginEnd<T>(), ForwardIterator<iterator_from<T>>()) {
-  };
-
-  template <typename T>
-  struct BidirectionalRange
-      : DefineConcept(HasBeginEnd<T>(),
-                      BidirectionalIterator<iterator_from<T>>()) {
-  };
-
-  template <typename T>
-  struct RandomAccessRange
-      : DefineConcept(HasBeginEnd<T>(),
-                      RandomAccessIterator<iterator_from<T>>()) {
-  };
 
 }  // end namespace concepts
 
 namespace type_traits
 {
-  DefineTypeTraitFromConcept(is_iterator, camp::concepts::Iterator);
-  DefineTypeTraitFromConcept(is_forward_iterator,
-                             camp::concepts::ForwardIterator);
-  DefineTypeTraitFromConcept(is_bidirectional_iterator,
-                             camp::concepts::BidirectionalIterator);
-  DefineTypeTraitFromConcept(is_random_access_iterator,
-                             camp::concepts::RandomAccessIterator);
-
-  DefineTypeTraitFromConcept(is_range, camp::concepts::Range);
-  DefineTypeTraitFromConcept(is_forward_range, camp::concepts::ForwardRange);
-  DefineTypeTraitFromConcept(is_bidirectional_range,
-                             camp::concepts::BidirectionalRange);
-  DefineTypeTraitFromConcept(is_random_access_range,
-                             camp::concepts::RandomAccessRange);
-
-  DefineTypeTraitFromConcept(is_comparable, camp::concepts::Comparable);
-  DefineTypeTraitFromConcept(is_comparable_to, camp::concepts::ComparableTo);
-
-  DefineTypeTraitFromConcept(is_arithmetic, camp::concepts::Arithmetic);
-  DefineTypeTraitFromConcept(is_floating_point, camp::concepts::FloatingPoint);
-  DefineTypeTraitFromConcept(is_integral, camp::concepts::Integral);
-  DefineTypeTraitFromConcept(is_signed, camp::concepts::Signed);
-  DefineTypeTraitFromConcept(is_unsigned, camp::concepts::Unsigned);
 
   template <typename T>
   using IterableValue = decltype(*std::begin(camp::val<T>()));
diff --git a/include/camp/defines.hpp b/include/camp/defines.hpp
index 7ddcc4d6..d3206294 100644
--- a/include/camp/defines.hpp
+++ b/include/camp/defines.hpp
@@ -58,6 +58,7 @@ namespace camp
 #elif defined(__HIPCC__)
 #define CAMP_DEVICE __device__
 #define CAMP_HOST_DEVICE __host__ __device__
+#define CAMP_HAVE_HIP
 #define CAMP_SUPPRESS_HD_WARN
 
 #else
@@ -72,8 +73,14 @@ namespace camp
 #endif
 #endif
 
-#if defined(__HIPCC__)
-#define CAMP_HAVE_HIP
+#if defined(__cpp_variable_templates) && __cpp_variable_templates >= 201304
+#define CAMP_HAS_VARIABLE_TEMPLATES 1
+#endif
+#if defined(__cpp_inline_variables)
+#define CAMP_HAS_INLINE_VARIABLE 1
+#define CAMP_INLINE_VARIABLE inline
+#else
+#define CAMP_INLINE_VARIABLE
 #endif
 
 // Types
diff --git a/include/camp/helpers.hpp b/include/camp/helpers.hpp
index dec0f3b6..5d386de4 100644
--- a/include/camp/helpers.hpp
+++ b/include/camp/helpers.hpp
@@ -148,8 +148,6 @@ template <typename Ret, typename T>
 Ret returns(T const&) noexcept;
 
 // bring common utility routines into scope to allow ADL
-using std::begin;
-using std::swap;
 
 template <typename T>
 using decay = type::cv::rem<type::ref::rem<T>>;
@@ -162,11 +160,21 @@ using diff_from = decltype(val<plain<T>>() - val<plain<T>>());
 template <typename T, typename U>
 using diff_between = decltype(val<plain<T>>() - val<plain<U>>());
 
+namespace detail
+{
+  namespace iter_from_
+  {
+    using std::begin;
+    template <typename T>
+    using iterator_from_impl = decltype(begin(val<plain<T>>()));
+  }
+}  // namespace detail
+
 template <typename T>
-using iterator_from = decltype(begin(val<plain<T>>()));
+using iterator_from = detail::iter_from_::iterator_from_impl<T>;
 
-template <class T>
-CAMP_HOST_DEVICE constexpr T&& forward(type::ref::rem<T>& t) noexcept
+    template <class T>
+    CAMP_HOST_DEVICE constexpr T&& forward(type::ref::rem<T>& t) noexcept
 {
   return static_cast<T&&>(t);
 }
diff --git a/include/camp/type_traits/detect.hpp b/include/camp/type_traits/detect.hpp
index 67e68b85..01bb7689 100644
--- a/include/camp/type_traits/detect.hpp
+++ b/include/camp/type_traits/detect.hpp
@@ -51,8 +51,6 @@ namespace detail
     using type = Concept<Args...>;
   };
 
-  template <typename... T>
-  camp::true_type ___valid_expr___(T &&...) noexcept;
 }  // namespace detail
 
 /// Detect whether a given template/alias Op can be expanded to a valid type
@@ -60,6 +58,12 @@ namespace detail
 template <template <class...> class Op, class... Args>
 using is_detected = detail::_detector<detail::nonesuch, void, Op, Args...>;
 
+template <template <class...> class Op, class... Args>
+constexpr bool detect()
+{
+  return is_detected<Op, Args...>::value;
+}
+
 template <template <class...> class Op, class... Args>
 using detected_t = typename is_detected<Op, Args...>::type;
 
@@ -73,9 +77,21 @@ using detected_or_t = typename detected_or<Default, Op, Args...>::type;
 template <class Expected, template <class...> class Op, class... Args>
 using is_detected_exact = is_same<Expected, detected_t<Op, Args...>>;
 
+template <class Expected, template <class...> class Op, class... Args>
+constexpr bool detect_exact()
+{
+  return is_detected_exact<Expected, Op, Args...>::value;
+}
+
 template <class To, template <class...> class Op, class... Args>
 using is_detected_convertible = is_convertible<detected_t<Op, Args...>, To>;
 
+template <class To, template <class...> class Op, class... Args>
+constexpr bool detect_convertible()
+{
+  return is_detected_convertible<To, Op, Args...>::value;
+}
+
 
 #define CAMP_DEF_DETECTOR(name, params, ...)                   \
   template <CAMP_UNQUOTE params, typename __Res = __VA_ARGS__> \
@@ -89,16 +105,70 @@ using is_detected_convertible = is_convertible<detected_t<Op, Args...>, To>;
   template <class T, class U, typename __Res = __VA_ARGS__> \
   using name = __Res
 
+#define CAMP_DEF_REQUIREMENT(name, params, ...) \
+  CAMP_DEF_DETECTOR(name, params, decltype((__VA_ARGS__)))
+
+#define CAMP_DEF_REQUIREMENT_T(name, ...) \
+  CAMP_DEF_REQUIREMENT(name, (class T), __VA_ARGS__)
+
+#define CAMP_DEF_REQUIREMENT_TU(name, ...) \
+  CAMP_DEF_REQUIREMENT(name, (class T, class U), __VA_ARGS__)
+
+
+#ifdef HAVE_CONCEPTS
 #define CAMP_DEF_CONCEPT(name, params, ...) \
-  CAMP_DEF_DETECTOR(name,                   \
-                    params,                 \
-                    decltype(::camp::detail::___valid_expr___(__VA_ARGS__)))
+  template <CAMP_UNQUOTE params>            \
+  concept name = __VA_ARGS__
+
+#define CAMP_REQ(name, ...) name<__VA_ARGS__>
+#elif defined(__cpp_variable_templates) && __cpp_variable_templates >= 201304
+#define CAMP_DEF_CONCEPT(name, params, ...) \
+  template <CAMP_UNQUOTE params>            \
+  CAMP_INLINE_VARIABLE constexpr bool name = __VA_ARGS__
+#define CAMP_REQ(name, ...) name<__VA_ARGS__>
+#else
+#define CAMP_DEF_CONCEPT(name, params, ...) \
+  template <CAMP_UNQUOTE params>            \
+  constexpr bool name##_c()                 \
+  {                                         \
+    return (__VA_ARGS__);                   \
+  }
+#define CAMP_REQ(name, ...) name##_c<__VA_ARGS__>()
+#endif
 
 #define CAMP_DEF_CONCEPT_T(name, ...) \
   CAMP_DEF_CONCEPT(name, (class T), __VA_ARGS__)
-
 #define CAMP_DEF_CONCEPT_TU(name, ...) \
   CAMP_DEF_CONCEPT(name, (class T, class U), __VA_ARGS__)
 
+#if defined(CAMP_HAS_VARIABLE_TEMPLATES)
+#define CAMP_MAKE_V_FROM_CONCEPT(CONCEPT, TT) \
+  template <typename... Types>                \
+  constexpr auto TT##_v = CAMP_REQ(CONCEPT, Types...)
+#else
+#define CAMP_MAKE_V_FROM_CONCEPT(X, Y)
+#endif
+
+
+#define CAMP_TYPE_TRAITS_FROM_CONCEPT(CONCEPT, TT)           \
+  template <typename... Types>                               \
+  struct TT : num<CAMP_REQ(CONCEPT, Types...)> { \
+  };                                                         \
+  template <typename... Types>                               \
+  using TT##_t = typename TT<Types...>::type;          \
+  CAMP_MAKE_V_FROM_CONCEPT(CONCEPT, TT)
+
+#define CAMP_DEF_CONCEPT_AND_TRAITS(CONCEPT, TT, params, ...) \
+  CAMP_DEF_CONCEPT(CONCEPT, params, __VA_ARGS__);             \
+  CAMP_TYPE_TRAITS_FROM_CONCEPT(CONCEPT, TT)
+
+#define CAMP_DEF_CONCEPT_AND_TRAITS_T(CONCEPT, TT, ...) \
+  CAMP_DEF_CONCEPT_T(CONCEPT, __VA_ARGS__);             \
+  CAMP_TYPE_TRAITS_FROM_CONCEPT(CONCEPT, TT)
+
+#define CAMP_DEF_CONCEPT_AND_TRAITS_TU(CONCEPT, TT, ...) \
+  CAMP_DEF_CONCEPT_TU(CONCEPT, __VA_ARGS__);             \
+  CAMP_TYPE_TRAITS_FROM_CONCEPT(CONCEPT, TT)
+
 }  // namespace camp
 #endif  // CAMP_DETECT_HPP
diff --git a/test/detect.cpp b/test/detect.cpp
index 26eba10e..b9f30c79 100644
--- a/test/detect.cpp
+++ b/test/detect.cpp
@@ -6,6 +6,10 @@
 #include <camp/helpers.hpp>
 #include <camp/list.hpp>
 #include <camp/type_traits/detect.hpp>
+#include <camp/concepts.hpp>
+
+#include <list>
+#include <vector>
 
 using namespace camp;
 
@@ -19,6 +23,51 @@ template <int I>
 struct D : A {
 };
 
+template<template<typename...> class Op, class T, class _Res = decltype(is(Op<T>()))>
+using invoke_is = _Res;
+
+CAMP_DEF_CONCEPT_AND_TRAITS_T(Arith, is_arithmetic, std::is_arithmetic<T>::value);
+
+// CAMP_DEF_CONCEPT_T(Arith, std::is_arithmetic<T>());
+// CAMP_DEF_DETECTOR_T(Arith, invoke_is<std::is_arithmetic,T>);
+static_assert(std::is_arithmetic<int>::value, "int is not arithmetic");
+// static_assert(decltype(concepts::is(std::is_arithmetic<A>()))::value, "A is not arithmetic");
+// static_assert(decltype(concepts::is(std::is_arithmetic<int>()))::value, "int is not arithmetic");
+static_assert(CAMP_REQ(Arith, int), "int is arithmetic");
+static_assert(is_arithmetic<int>::value, "int is arithmetic");
+static_assert(!is_arithmetic<A>::value, "A is not arithmetic");
+// CAMP_CHECK_VALUE_NOT(is_detected<Arith, A>);
+// CAMP_CHECK_VALUE(is_detected<Arith, int>);
+// CAMP_CHECK_VALUE(is_detected<Arith, float>);
+// CAMP_CHECK_VALUE_NOT(is_detected<concepts::Arithmetic, A>);
+
+static_assert(CAMP_REQ(concepts::comparable, int), "int can be compared with int");
+static_assert(CAMP_REQ(concepts::equality_comparable, int), "int can be compared with int");
+static_assert(CAMP_REQ(concepts::equality_comparable_with, int, long), "int and long can be compared");
+static_assert(!CAMP_REQ(concepts::equality_comparable_with, A, long), "A and long can't be compared");
+
+struct eq_only {
+  bool operator==(eq_only const&o) {
+    return true;
+  }
+  bool operator!=(eq_only const&o) {
+    return false;
+  }
+};
+static_assert(!CAMP_REQ(concepts::comparable, eq_only), "eq_only is not comparable");
+static_assert(CAMP_REQ(concepts::equality_comparable, eq_only), "eq_only is equality comparable");
+
+static_assert(!CAMP_REQ(concepts::iterator, eq_only), "eq_only is not an iterator");
+static_assert(CAMP_REQ(concepts::iterator, int *), "int* is an iterator");
+static_assert(CAMP_REQ(concepts::iterator, decltype(val<std::vector<int>>().begin())), "int* is an iterator");
+
+static_assert(!CAMP_REQ(concepts::random_access_iterator, decltype(val<std::list<int>>().begin())), "list iterator is not random access");
+static_assert(CAMP_REQ(concepts::random_access_iterator, int *), "int* is an iterator");
+static_assert(CAMP_REQ(concepts::random_access_iterator, decltype(val<std::vector<int>>().begin())), "int* is an iterator");
+
+static_assert(!CAMP_REQ(concepts::random_access_range, decltype(val<std::list<int>>())), "list iterator is not random access");
+static_assert(CAMP_REQ(concepts::random_access_range, decltype(val<std::vector<int>>())), "int* is an iterator");
+
 struct TC1 {
   using my_member_type = C;
 
@@ -39,16 +88,13 @@ struct TC1 {
   TC1& my_method_with_overloads(A const&);
 };
 
-// TODO test these in other scopes that could trip up compilers, like function
-// scope or dependent class template scope
-
+// tests courtesy of Kokkos and David Hollman
 CAMP_DEF_DETECTOR(_my_member_type_missing,
                   (class T),
                   typename T::my_member_type_missing);
 
 CAMP_CHECK_VALUE_NOT(is_detected<_my_member_type_missing, TC1>);
 
-// tests courtesy of Kokkos and David Hollman
 //  template <class T>
 //  using _my_member_type_archetype = typename T::my_member_type;
 CAMP_DEF_DETECTOR_T(_my_member_type_archetype, typename T::my_member_type);
@@ -60,7 +106,7 @@ CAMP_CHECK_VALUE(is_detected_exact<C, _my_member_type_archetype, TC1>);
 CAMP_CHECK_VALUE(is_detected_convertible<C, _my_member_type_archetype, TC1>);
 
 
-CAMP_DEF_DETECTOR_T(_my_method_archetype_1, decltype(T{}.my_method()));
+CAMP_DEF_REQUIREMENT_T(_my_method_archetype_1,T{}.my_method());
 
 CAMP_DEF_DETECTOR_T(_my_method_archetype_2, decltype(declval<T>().my_method()));
 

From e0d0041d09872b8d0221511e6a5f4dd4ba445280 Mon Sep 17 00:00:00 2001
From: Tom Scogland <scogland1@llnl.gov>
Date: Thu, 14 Nov 2019 14:37:59 -0800
Subject: [PATCH 07/19] add missing enable_if file

---
 include/camp/type_traits/enable_if.hpp | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 include/camp/type_traits/enable_if.hpp

diff --git a/include/camp/type_traits/enable_if.hpp b/include/camp/type_traits/enable_if.hpp
new file mode 100644
index 00000000..12c7d681
--- /dev/null
+++ b/include/camp/type_traits/enable_if.hpp
@@ -0,0 +1,21 @@
+#ifndef __CAMP_TYPE_TRAITS_ENABLE_IF
+#define __CAMP_TYPE_TRAITS_ENABLE_IF
+
+namespace camp
+{
+
+template <bool B, class T = void>
+struct enable_if {
+};
+
+template <class T>
+struct enable_if<true, T> {
+  typedef T type;
+};
+
+template <bool B, class T = void>
+using enable_if_t = typename enable_if<B, T>::type;
+
+}  // namespace camp
+
+#endif /* __CAMP_TYPE_TRAITS_ENABLE_IF */

From d781ad03c3c406ee1afe5a9e97bea898ab8cb824 Mon Sep 17 00:00:00 2001
From: Tom Scogland <scogland1@llnl.gov>
Date: Thu, 14 Nov 2019 14:40:47 -0800
Subject: [PATCH 08/19] fix c++14 variable template bool concepts backup

---
 include/camp/concepts.hpp | 134 +-------------------------------------
 1 file changed, 3 insertions(+), 131 deletions(-)

diff --git a/include/camp/concepts.hpp b/include/camp/concepts.hpp
index 19ef67f2..e63a2f22 100644
--- a/include/camp/concepts.hpp
+++ b/include/camp/concepts.hpp
@@ -24,120 +24,9 @@ For details about use and distribution, please read LICENSE and NOTICE from
 
 namespace camp
 {
-
 namespace concepts
 {
 
-  namespace metalib
-  {
-    using camp::is_same;
-
-    /// negation metafunction of a value type
-    template <typename T>
-    struct negate_t : num<!T::value> {
-    };
-
-    /// all_of metafunction of a value type list -- all must be "true"
-    template <bool... Bs>
-    struct all_of : metalib::is_same<list<t, num<Bs>...>, list<num<Bs>..., t>> {
-    };
-
-    /// none_of metafunction of a value type list -- all must be "false"
-    template <bool... Bs>
-    struct none_of
-        : metalib::is_same<idx_seq<false, Bs...>, idx_seq<Bs..., false>> {
-    };
-
-    /// any_of metafunction of a value type list -- at least one must be "true""
-    template <bool... Bs>
-    struct any_of : negate_t<none_of<Bs...>> {
-    };
-
-    /// all_of metafunction of a bool list -- all must be "true"
-    template <typename... Bs>
-    struct all_of_t : all_of<Bs::value...> {
-    };
-
-    /// none_of metafunction of a bool list -- all must be "false"
-    template <typename... Bs>
-    struct none_of_t : none_of<Bs::value...> {
-    };
-
-    /// any_of metafunction of a bool list -- at least one must be "true""
-    template <typename... Bs>
-    struct any_of_t : any_of<Bs::value...> {
-    };
-
-  }  // end namespace metalib
-
-}  // end namespace concepts
-}  // end namespace camp
-
-#define DefineConcept(...) decltype((__VA_ARGS__, true_type()))
-
-#define DefineTypeTraitFromConcept(TTName, ConceptName)       \
-  template <typename... Args>                                 \
-  struct TTName : ::camp::is_detected<ConceptName, Args...> { \
-  }
-namespace camp
-{
-namespace concepts
-{
-
-  namespace detail
-  {
-    template <typename Ret, typename T>
-    Ret returns(T const &) noexcept;
-
-  }  // end namespace detail
-
-  template <typename T>
-  using negate = metalib::negate_t<T>;
-
-  /// metafunction for use within decltype expression to validate return type is
-  /// convertible to given type
-  template <typename T, typename U>
-  constexpr auto convertible_to(U &&u) noexcept
-      -> decltype(detail::returns<camp::true_type>(static_cast<T>((U &&) u)));
-
-  /// metafunction for use within decltype expression to validate type of
-  /// expression
-  template <typename T, typename U>
-  constexpr auto has_type(U &&) noexcept -> metalib::is_same<T, U>;
-
-  template <typename BoolLike>
-  constexpr auto is(BoolLike) noexcept
-      -> camp::enable_if_t<BoolLike::value, true_type>
-  {
-    return {};
-  }
-
-  template <typename BoolLike, camp::enable_if_t<!BoolLike::value, int> = 0>
-  constexpr true_type is_not(BoolLike) noexcept
-  {
-    return {};
-  }
-
-  /// metaprogramming concept for SFINAE checking of aggregating concepts
-  template <typename... Args>
-  struct all_of : metalib::all_of_t<Args...> {
-  };
-
-  /// metaprogramming concept for SFINAE checking of aggregating concepts
-  template <typename... Args>
-  struct none_of : metalib::none_of_t<Args...> {
-  };
-
-  /// metaprogramming concept for SFINAE checking of aggregating concepts
-  template <typename... Args>
-  struct any_of : metalib::any_of_t<Args...> {
-  };
-
-  /// SFINAE concept checking
-  template <template <class...> class Op, class... Args>
-  struct requires_ : is_detected<Op, Args...> {
-  };
-
   // TODO: add a proper ranges-style swap and update this
   CAMP_DEF_REQUIREMENT_T(Swappable, swap(val<T>(), val<T>()));
 
@@ -193,8 +82,8 @@ namespace concepts
   CAMP_DEF_CONCEPT_AND_TRAITS_T(integral,
                                 is_integral,
                                 std::is_integral<T>::value);
-  CAMP_DEF_CONCEPT_AND_TRAITS_T(signed, is_signed, std::is_signed<T>::value);
-  CAMP_DEF_CONCEPT_AND_TRAITS_T(unsigned,
+  CAMP_DEF_CONCEPT_AND_TRAITS_T(Signed, is_signed, std::is_signed<T>::value);
+  CAMP_DEF_CONCEPT_AND_TRAITS_T(Unsigned,
                                 is_unsigned,
                                 std::is_unsigned<T>::value);
 
@@ -286,23 +175,6 @@ namespace concepts
       (detect<BeginMember, T>() || detect<BeginFree>())
           && (detect<EndMember, T>() || detect<EndFree>()));
 
-  // template <typename T>
-  // struct Range : DefineConcept(HasBeginEnd<T>(),
-  // Iterator<iterator_from<T>>()) {
-  // };
-  //
-  // template <typename T>
-  // struct ForwardRange
-  //     : DefineConcept(HasBeginEnd<T>(), ForwardIterator<iterator_from<T>>())
-  //     {
-  // };
-  //
-  // template <typename T>
-  // struct BidirectionalRange
-  //     : DefineConcept(HasBeginEnd<T>(),
-  //                     BidirectionalIterator<iterator_from<T>>()) {
-  // };
-
   CAMP_DEF_CONCEPT_AND_TRAITS_T(random_access_range,
                                 is_random_access_range,
                                 CAMP_REQ(has_begin_end, T)
@@ -349,7 +221,7 @@ namespace type_traits
               class Actual,
               class... Args>
     struct SpecializationOf<Expected, Actual, true, Args...>
-        : camp::concepts::metalib::is_same<Expected<Args...>, Actual<Args...>> {
+        : camp::is_same<Expected<Args...>, Actual<Args...>> {
     };
     /// \endcond
 

From e12f75ce896ca079da01a25c2575d130edf17e56 Mon Sep 17 00:00:00 2001
From: Tom Scogland <scogland1@llnl.gov>
Date: Thu, 14 Nov 2019 17:01:54 -0800
Subject: [PATCH 09/19] performance-oriented refactor

Remove unnecessary stl headers, factor out their usage, also use
builtins for typelist lookups when available.
---
 include/camp/concepts.hpp                  |   2 +-
 include/camp/defines.hpp                   |  13 +++
 include/camp/helpers.hpp                   |  20 +---
 include/camp/list/at.hpp                   |  15 ++-
 include/camp/list/list.hpp                 |  36 ++++++-
 include/camp/number.hpp                    | 119 +--------------------
 include/camp/number/int_seq.hpp            |  18 ++++
 include/camp/number/make_seq.hpp           | 116 ++++++++++++++++++++
 include/camp/number/number.hpp             |   6 ++
 include/camp/tuple.hpp                     |  42 ++------
 include/camp/tuple/print_tuple.hpp         |  24 +++++
 include/camp/type_traits/iterator_from.hpp |  34 ++++++
 test/tuple.cpp                             |  96 +++++++++--------
 13 files changed, 324 insertions(+), 217 deletions(-)
 create mode 100644 include/camp/number/int_seq.hpp
 create mode 100644 include/camp/number/make_seq.hpp
 create mode 100644 include/camp/tuple/print_tuple.hpp
 create mode 100644 include/camp/type_traits/iterator_from.hpp

diff --git a/include/camp/concepts.hpp b/include/camp/concepts.hpp
index e63a2f22..5f22e8ba 100644
--- a/include/camp/concepts.hpp
+++ b/include/camp/concepts.hpp
@@ -11,7 +11,6 @@ For details about use and distribution, please read LICENSE and NOTICE from
 #ifndef CAMP_CONCEPTS_HPP
 #define CAMP_CONCEPTS_HPP
 
-#include <iterator>
 #include <type_traits>
 
 #include "helpers.hpp"
@@ -21,6 +20,7 @@ For details about use and distribution, please read LICENSE and NOTICE from
 #include "type_traits/detect.hpp"
 #include "type_traits/enable_if.hpp"
 #include "type_traits/is_same.hpp"
+#include "type_traits/iterator_from.hpp"
 
 namespace camp
 {
diff --git a/include/camp/defines.hpp b/include/camp/defines.hpp
index d3206294..6f9e38b5 100644
--- a/include/camp/defines.hpp
+++ b/include/camp/defines.hpp
@@ -71,7 +71,20 @@ namespace camp
 #if __has_builtin(__make_integer_seq)
 #define CAMP_USE_MAKE_INTEGER_SEQ 1
 #endif
+#elif _MSC_FULL_VER >= 190023918
+#define CAMP_USE_MAKE_INTEGER_SEQ 1
+#endif
+
+#if __GNUC__ >= 8
+#define CAMP_USE_INTEGER_PACK 1
+#endif
+
+#if defined(__has_builtin)
+#if __has_builtin(__type_pack_element)
+#define CAMP_USE_TYPE_PACK_ELEMENT 1
 #endif
+#endif
+
 
 #if defined(__cpp_variable_templates) && __cpp_variable_templates >= 201304
 #define CAMP_HAS_VARIABLE_TEMPLATES 1
diff --git a/include/camp/helpers.hpp b/include/camp/helpers.hpp
index 5d386de4..c80c7597 100644
--- a/include/camp/helpers.hpp
+++ b/include/camp/helpers.hpp
@@ -12,10 +12,10 @@ For details about use and distribution, please read LICENSE and NOTICE from
 #define CAMP_HELPERS_HPP
 
 #include <cstddef>
-#include <iterator>
 #include <utility>
 
-#include "camp/defines.hpp"
+#include "defines.hpp"
+#include "type_traits/enable_if.hpp"
 
 namespace camp
 {
@@ -160,21 +160,9 @@ using diff_from = decltype(val<plain<T>>() - val<plain<T>>());
 template <typename T, typename U>
 using diff_between = decltype(val<plain<T>>() - val<plain<U>>());
 
-namespace detail
-{
-  namespace iter_from_
-  {
-    using std::begin;
-    template <typename T>
-    using iterator_from_impl = decltype(begin(val<plain<T>>()));
-  }
-}  // namespace detail
-
-template <typename T>
-using iterator_from = detail::iter_from_::iterator_from_impl<T>;
 
-    template <class T>
-    CAMP_HOST_DEVICE constexpr T&& forward(type::ref::rem<T>& t) noexcept
+template <class T>
+CAMP_HOST_DEVICE constexpr T&& forward(type::ref::rem<T>& t) noexcept
 {
   return static_cast<T&&>(t);
 }
diff --git a/include/camp/list/at.hpp b/include/camp/list/at.hpp
index 83aaf343..332f7cde 100644
--- a/include/camp/list/at.hpp
+++ b/include/camp/list/at.hpp
@@ -22,6 +22,16 @@ namespace camp
 
 namespace detail
 {
+
+  template <typename T, idx_t Idx>
+  struct _at;
+
+#if defined(CAMP_USE_TYPE_PACK_ELEMENT)
+  template <idx_t Idx, template <class...> class T, typename... Rest>
+  struct _at<T<Rest...>, Idx> {
+    using type = __type_pack_element<Idx, Rest...>;
+  };
+#else
   // Lookup from metal::at machinery
   template <idx_t, typename>
   struct entry {
@@ -44,9 +54,6 @@ namespace detail
   struct _lookup
       : decltype(_lookup_impl<Idx>(declptr<entries<indices, vals>>())) {
   };
-
-  template <typename T, idx_t Idx>
-  struct _at;
   template <template <class...> class T, typename X, typename... Rest>
   struct _at<T<X, Rest...>, 0> {
     using type = X;
@@ -65,11 +72,13 @@ namespace detail
                                   make_idx_seq_t<sizeof...(Rest)>,
                                   Idx>::type;
   };
+#endif
 }  // namespace detail
 
 // TODO: document
 template <typename Seq, typename Num>
 struct at;
+
 template <typename T, idx_t Val>
 struct at<T, num<Val>> {
   using type = typename detail::_at<T, Val>::type;
diff --git a/include/camp/list/list.hpp b/include/camp/list/list.hpp
index 12796dd1..e08f2fdc 100644
--- a/include/camp/list/list.hpp
+++ b/include/camp/list/list.hpp
@@ -11,8 +11,9 @@ For details about use and distribution, please read LICENSE and NOTICE from
 #ifndef CAMP_LIST_LIST_HPP
 #define CAMP_LIST_LIST_HPP
 
-#include "camp/number.hpp"
-#include "camp/size.hpp"
+#include "../number.hpp"
+#include "../size.hpp"
+#include "../type_traits/is_same.hpp"
 
 namespace camp
 {
@@ -50,6 +51,37 @@ struct size<list<Args...>> {
   using type = num<sizeof...(Args)>;
 };
 
+/// all_of metafunction of a value type list -- all must be "true"
+template <bool... Bs>
+struct all_of : is_same<list<t, num<Bs>...>, list<num<Bs>..., t>> {
+};
+
+/// none_of metafunction of a value type list -- all must be "false"
+template <bool... Bs>
+struct none_of
+    : is_same<idx_seq<false, Bs...>, idx_seq<Bs..., false>> {
+};
+
+/// any_of metafunction of a value type list -- at least one must be "true""
+template <bool... Bs>
+struct any_of : negate_t<none_of<Bs...>> {
+};
+
+/// all_of metafunction of a bool list -- all must be "true"
+template <typename... Bs>
+struct all_of_t : all_of<Bs::value...> {
+};
+
+/// none_of metafunction of a bool list -- all must be "false"
+template <typename... Bs>
+struct none_of_t : none_of<Bs::value...> {
+};
+
+/// any_of metafunction of a bool list -- at least one must be "true""
+template <typename... Bs>
+struct any_of_t : any_of<Bs::value...> {
+};
+
 }  // namespace camp
 
 #endif /* CAMP_LIST_LIST_HPP */
diff --git a/include/camp/number.hpp b/include/camp/number.hpp
index 42e53629..83064057 100644
--- a/include/camp/number.hpp
+++ b/include/camp/number.hpp
@@ -14,126 +14,11 @@ For details about use and distribution, please read LICENSE and NOTICE from
 #include "camp/helpers.hpp"
 #include "camp/number/if.hpp"
 #include "camp/number/number.hpp"
+#include "camp/number/int_seq.hpp"
+#include "camp/number/make_seq.hpp"
 
 #include "camp/defines.hpp"
 
-#include <array>
 #include <type_traits>
 
-namespace camp
-{
-
-// TODO: document
-template <typename T, T... vs>
-struct int_seq {
-  using type = int_seq;
-};
-/// Index list, use for indexing into parameter packs and lists
-template <idx_t... vs>
-using idx_seq = int_seq<idx_t, vs...>;
-
-namespace detail
-{
-  template <typename T, typename N>
-  struct gen_seq;
-#if defined(CAMP_USE_MAKE_INTEGER_SEQ) && !__NVCC__
-  template <typename T, T N>
-  struct gen_seq<T, integral_constant<T, N>> {
-    using type = __make_integer_seq<int_seq, T, N>;
-  };
-#else
-  template <typename T, typename S1, typename S2>
-  struct concat;
-
-  template <typename T, T... I1, T... I2>
-  struct concat<T, int_seq<T, I1...>, int_seq<T, I2...>> {
-    using type = typename int_seq<T, I1..., (sizeof...(I1) + I2)...>::type;
-  };
-
-  template <typename T, typename N_t>
-  struct gen_seq
-      : concat<T,
-               typename gen_seq<T, integral_constant<T, N_t::value / 2>>::type,
-               typename gen_seq<
-                   T,
-                   integral_constant<T, N_t::value - N_t::value / 2>>::type>::
-            type {
-  };
-
-  template <typename T>
-  struct gen_seq<T, integral_constant<T, 0>> : int_seq<T> {
-  };
-  template <typename T>
-  struct gen_seq<T, integral_constant<T, 1>> : int_seq<T, 0> {
-  };
-#endif
-}  // namespace detail
-
-// TODO: document
-template <idx_t Upper>
-struct make_idx_seq {
-  using type =
-      typename detail::gen_seq<idx_t, integral_constant<idx_t, Upper>>::type;
-};
-
-
-// TODO: document
-template <idx_t Upper>
-using make_idx_seq_t = typename make_idx_seq<Upper>::type;
-
-// TODO: document
-template <class... Ts>
-using idx_seq_for_t = typename make_idx_seq<sizeof...(Ts)>::type;
-
-// TODO: document
-template <typename T>
-struct idx_seq_from;
-
-// TODO: document
-template <template <typename...> class T, typename... Args>
-struct idx_seq_from<T<Args...>> : make_idx_seq<sizeof...(Args)> {
-};
-
-// TODO: document
-template <typename T, T... Args>
-struct idx_seq_from<int_seq<T, Args...>> : make_idx_seq<sizeof...(Args)> {
-};
-
-// TODO: document
-template <typename T>
-using idx_seq_from_t = typename idx_seq_from<camp::decay<T>>::type;
-
-// TODO: document
-template <typename T, T Upper>
-struct make_int_seq : detail::gen_seq<T, integral_constant<T, Upper>>::type {
-};
-
-// TODO: document
-template <typename T, idx_t Upper>
-using make_int_seq_t = typename make_int_seq<T, Upper>::type;
-
-// TODO: document
-template <typename T>
-struct not_ {
-  using type = typename if_s<T, false_type, true_type>::type;
-};
-
-
-template <idx_t N, typename IdxSeg>
-struct seq_at;
-
-template <idx_t N, idx_t Idx0, idx_t... IdxRest>
-struct seq_at<N, camp::idx_seq<Idx0, IdxRest...>> {
-  static constexpr idx_t value =
-      seq_at<N - 1, camp::idx_seq<IdxRest...>>::value;
-};
-
-template <idx_t Idx0, idx_t... IdxRest>
-struct seq_at<0, camp::idx_seq<Idx0, IdxRest...>> {
-  static constexpr idx_t value = Idx0;
-};
-
-
-}  // end namespace camp
-
 #endif /* CAMP_NUMBER_HPP */
diff --git a/include/camp/number/int_seq.hpp b/include/camp/number/int_seq.hpp
new file mode 100644
index 00000000..ea6aa973
--- /dev/null
+++ b/include/camp/number/int_seq.hpp
@@ -0,0 +1,18 @@
+#ifndef CAMP_INT_SEQ_HPP
+#define CAMP_INT_SEQ_HPP
+
+#include "../defines.hpp"
+
+namespace camp
+{
+// TODO: document
+template <typename T, T... vs>
+struct int_seq {
+  using type = int_seq;
+};
+/// Index list, use for indexing into parameter packs and lists
+template <idx_t... vs>
+using idx_seq = int_seq<idx_t, vs...>;
+}  // namespace camp
+
+#endif /* CAMP_INT_SEQ_HPP */
diff --git a/include/camp/number/make_seq.hpp b/include/camp/number/make_seq.hpp
new file mode 100644
index 00000000..dee32f67
--- /dev/null
+++ b/include/camp/number/make_seq.hpp
@@ -0,0 +1,116 @@
+#ifndef CAMP_NUMBER_SEQ_HPP
+#define CAMP_NUMBER_SEQ_HPP
+
+#include "number.hpp"
+
+namespace camp
+{
+
+namespace detail
+{
+  template <typename T, typename N>
+  struct gen_seq;
+#if defined(CAMP_USE_MAKE_INTEGER_SEQ) && !__NVCC__
+  template <typename T, T N>
+  struct gen_seq<T, integral_constant<T, N>> {
+    using type = __make_integer_seq<int_seq, T, N>;
+  };
+#elif CAMP_USE_INTEGER_PACK && !__NVCC__
+  template <typename T, T N>
+  struct gen_seq<T, integral_constant<T, N>> {
+    using type = int_seq<T, __integer_pack(N)...>;
+  };
+#else
+  template <typename T, typename S1, typename S2>
+  struct concat;
+
+  template <typename T, T... I1, T... I2>
+  struct concat<T, int_seq<T, I1...>, int_seq<T, I2...>> {
+    using type = typename int_seq<T, I1..., (sizeof...(I1) + I2)...>::type;
+  };
+
+  template <typename T, typename N_t>
+  struct gen_seq
+      : concat<T,
+               typename gen_seq<T, integral_constant<T, N_t::value / 2>>::type,
+               typename gen_seq<
+                   T,
+                   integral_constant<T, N_t::value - N_t::value / 2>>::type>::
+            type {
+  };
+
+  template <typename T>
+  struct gen_seq<T, integral_constant<T, 0>> : int_seq<T> {
+  };
+  template <typename T>
+  struct gen_seq<T, integral_constant<T, 1>> : int_seq<T, 0> {
+  };
+#endif
+}  // namespace detail
+
+// TODO: document
+template <idx_t Upper>
+struct make_idx_seq {
+  using type =
+      typename detail::gen_seq<idx_t, integral_constant<idx_t, Upper>>::type;
+};
+
+
+// TODO: document
+template <idx_t Upper>
+using make_idx_seq_t = typename make_idx_seq<Upper>::type;
+
+// TODO: document
+template <class... Ts>
+using idx_seq_for_t = typename make_idx_seq<sizeof...(Ts)>::type;
+
+// TODO: document
+template <typename T>
+struct idx_seq_from;
+
+// TODO: document
+template <template <typename...> class T, typename... Args>
+struct idx_seq_from<T<Args...>> : make_idx_seq<sizeof...(Args)> {
+};
+
+// TODO: document
+template <typename T, T... Args>
+struct idx_seq_from<int_seq<T, Args...>> : make_idx_seq<sizeof...(Args)> {
+};
+
+// TODO: document
+template <typename T>
+using idx_seq_from_t = typename idx_seq_from<camp::decay<T>>::type;
+
+// TODO: document
+template <typename T, T Upper>
+struct make_int_seq : detail::gen_seq<T, integral_constant<T, Upper>>::type {
+};
+
+// TODO: document
+template <typename T, idx_t Upper>
+using make_int_seq_t = typename make_int_seq<T, Upper>::type;
+
+// TODO: document
+template <typename T>
+struct not_ {
+  using type = typename if_s<T, false_type, true_type>::type;
+};
+
+
+template <idx_t N, typename IdxSeg>
+struct seq_at;
+
+template <idx_t N, idx_t Idx0, idx_t... IdxRest>
+struct seq_at<N, camp::idx_seq<Idx0, IdxRest...>> {
+  static constexpr idx_t value =
+      seq_at<N - 1, camp::idx_seq<IdxRest...>>::value;
+};
+
+template <idx_t Idx0, idx_t... IdxRest>
+struct seq_at<0, camp::idx_seq<Idx0, IdxRest...>> {
+  static constexpr idx_t value = Idx0;
+};
+}  // namespace camp
+
+#endif /* CAMP_NUMBER_SEQ_HPP */
diff --git a/include/camp/number/number.hpp b/include/camp/number/number.hpp
index 074c9cbd..98b82d36 100644
--- a/include/camp/number/number.hpp
+++ b/include/camp/number/number.hpp
@@ -39,6 +39,12 @@ using false_type = num<false>;
 
 using t = num<true>;
 
+/// negation metafunction of a value type
+template <typename T>
+struct negate_t : num<!T::value> {
+};
+
+
 }  // end namespace camp
 
 #endif /* CAMP_NUMBER_NUMBER_HPP */
diff --git a/include/camp/tuple.hpp b/include/camp/tuple.hpp
index f062071f..561c1adf 100644
--- a/include/camp/tuple.hpp
+++ b/include/camp/tuple.hpp
@@ -20,7 +20,6 @@ For details about use and distribution, please read LICENSE and NOTICE from
 #include "camp/camp.hpp"
 #include "camp/concepts.hpp"
 
-#include <iostream>
 #include <type_traits>
 
 namespace camp
@@ -124,20 +123,20 @@ namespace internal
   template <typename... Types, camp::idx_t... Indices>
   struct tuple_helper<camp::idx_seq<Indices...>, camp::list<Types...>>
       : public internal::tuple_storage<Indices, Types>... {
-    template <bool B = concepts::metalib::all_of<
-                  std::is_default_constructible<Types>::value...>::value,
-              typename std::enable_if<B, void>::type* = nullptr>
+    template <
+        bool B = all_of<std::is_default_constructible<Types>::value...>::value,
+        typename std::enable_if<B, void>::type* = nullptr>
     CAMP_HOST_DEVICE constexpr tuple_helper()
     {
     }
     CAMP_HOST_DEVICE constexpr tuple_helper(tuple_helper const& rhs)
         : tuple_storage<Indices, Types>(
-              rhs.tuple_storage<Indices, Types>::get_inner())...
+            rhs.tuple_storage<Indices, Types>::get_inner())...
     {
     }
     CAMP_HOST_DEVICE constexpr tuple_helper(tuple_helper&& rhs)
         : tuple_storage<Indices, Types>(
-              std::forward<Types>(rhs.tuple_storage<Indices, Types>::val))...
+            std::forward<Types>(rhs.tuple_storage<Indices, Types>::val))...
     {
     }
 
@@ -223,9 +222,9 @@ struct tuple {
 public:
   // NOTE: __host__ __device__ on constructors causes warnings, and nothing else
   // Constructors
-  template <bool B = concepts::metalib::all_of<
-                std::is_default_constructible<Elements>::value...>::value,
-            typename std::enable_if<B, void>::type* = nullptr>
+  template <
+      bool B = all_of<std::is_default_constructible<Elements>::value...>::value,
+      typename std::enable_if<B, void>::type* = nullptr>
   CAMP_HOST_DEVICE constexpr tuple() : base()
   {
   }
@@ -317,9 +316,9 @@ class tagged_tuple : public tuple<Elements...>
 public:
   // NOTE: __host__ __device__ on constructors causes warnings, and nothing else
   // Constructors
-  template <bool B = concepts::metalib::all_of<
-                std::is_default_constructible<Elements>::value...>::value,
-            typename std::enable_if<B, void>::type* = nullptr>
+  template <
+      bool B = all_of<std::is_default_constructible<Elements>::value...>::value,
+      typename std::enable_if<B, void>::type* = nullptr>
   CAMP_HOST_DEVICE constexpr tagged_tuple() : base()
   {
   }
@@ -513,23 +512,4 @@ CAMP_HOST_DEVICE constexpr auto invoke(TupleLike&& t, Fn&& f) -> decltype(
 }
 }  // namespace camp
 
-namespace internal
-{
-template <class Tuple, camp::idx_t... Idxs>
-void print_tuple(std::ostream& os, Tuple const& t, camp::idx_seq<Idxs...>)
-{
-  camp::sink((void*)&(os << (Idxs == 0 ? "" : ", ") << camp::get<Idxs>(t))...);
-}
-}  // namespace internal
-
-template <class... Args>
-auto operator<<(std::ostream& os, camp::tuple<Args...> const& t)
-    -> std::ostream&
-{
-  os << "(";
-  internal::print_tuple(os, t, camp::make_idx_seq_t<sizeof...(Args)>{});
-  return os << ")";
-}
-
-
 #endif /* camp_tuple_HPP__ */
diff --git a/include/camp/tuple/print_tuple.hpp b/include/camp/tuple/print_tuple.hpp
new file mode 100644
index 00000000..e612253a
--- /dev/null
+++ b/include/camp/tuple/print_tuple.hpp
@@ -0,0 +1,24 @@
+#ifndef CAMP_TUPLE_PRINT_TUPLE_HPP
+#define CAMP_TUPLE_PRINT_TUPLE_HPP
+
+#include <iostream>
+
+namespace internal
+{
+template <class Tuple, camp::idx_t... Idxs>
+void print_tuple(std::ostream& os, Tuple const& t, camp::idx_seq<Idxs...>)
+{
+  camp::sink((void*)&(os << (Idxs == 0 ? "" : ", ") << camp::get<Idxs>(t))...);
+}
+}  // namespace internal
+
+template <class... Args>
+auto operator<<(std::ostream& os, camp::tuple<Args...> const& t)
+    -> std::ostream&
+{
+  os << "(";
+  internal::print_tuple(os, t, camp::make_idx_seq_t<sizeof...(Args)>{});
+  return os << ")";
+}
+
+#endif /* CAMP_TUPLE_PRINT_TUPLE_HPP */
diff --git a/include/camp/type_traits/iterator_from.hpp b/include/camp/type_traits/iterator_from.hpp
new file mode 100644
index 00000000..55f4f418
--- /dev/null
+++ b/include/camp/type_traits/iterator_from.hpp
@@ -0,0 +1,34 @@
+#ifndef __CAMP_TYPE_TRAITS_ITERATOR_FROM
+#define __CAMP_TYPE_TRAITS_ITERATOR_FROM
+
+#include "detect.hpp"
+#include "enable_if.hpp"
+
+namespace camp
+{
+namespace detail
+{
+  namespace iter_from_
+  {
+    CAMP_DEF_REQUIREMENT_T(BeginMember, val<T>().begin());
+    CAMP_DEF_REQUIREMENT_T(BeginFree, begin(val<T>()));
+    template <typename T, typename Enable = void>
+    struct iterator_from_impl {
+    };
+    template <typename T>
+    struct iterator_from_impl<T, enable_if_t<detect<BeginMember, T>(), void>> {
+      using type = decltype(val<T>().begin());
+    };
+    template <typename T>
+    struct iterator_from_impl<T, enable_if_t<(!detect<BeginMember, T>()) && detect<BeginFree, T>(), void>> {
+      using type = decltype(begin(val<T>()));
+    };
+  }  // namespace iter_from_
+}  // namespace detail
+
+template <typename T>
+using iterator_from = typename detail::iter_from_::iterator_from_impl<T>::type;
+
+}  // namespace camp
+
+#endif /* __CAMP_TYPE_TRAITS_ITERATOR_FROM */
diff --git a/test/tuple.cpp b/test/tuple.cpp
index f6801cff..3c65ff1a 100644
--- a/test/tuple.cpp
+++ b/test/tuple.cpp
@@ -16,76 +16,78 @@
 #include "camp/camp.hpp"
 #include "gtest/gtest.h"
 
+using namespace camp;
+
 TEST(CampTuple, AssignCompat)
 {
   // Compatible, though different, tuples are assignable
-  const camp::tuple<long long, char> t(5, 'a');
-  ASSERT_EQ(camp::get<0>(t), 5);
-  ASSERT_EQ(camp::get<1>(t), 'a');
+  const tuple<long long, char> t(5, 'a');
+  ASSERT_EQ(get<0>(t), 5);
+  ASSERT_EQ(get<1>(t), 'a');
 
-  camp::tagged_tuple<camp::list<int, char>, int, char> t2;
+  tagged_tuple<list<int, char>, int, char> t2;
   t2 = t;
-  ASSERT_EQ(camp::get<0>(t2), 5);
-  ASSERT_EQ(camp::get<1>(t2), 'a');
+  ASSERT_EQ(get<0>(t2), 5);
+  ASSERT_EQ(get<1>(t2), 'a');
 }
 
 TEST(CampTuple, Assign)
 {
-  camp::tuple<int, char> t(5, 'a');
-  ASSERT_EQ(camp::get<0>(t), 5);
-  ASSERT_EQ(camp::get<1>(t), 'a');
+  tuple<int, char> t(5, 'a');
+  ASSERT_EQ(get<0>(t), 5);
+  ASSERT_EQ(get<1>(t), 'a');
 
-  camp::tuple<int, char> t2 = t;
-  ASSERT_EQ(camp::get<0>(t2), 5);
-  ASSERT_EQ(camp::get<1>(t2), 'a');
+  tuple<int, char> t2 = t;
+  ASSERT_EQ(get<0>(t2), 5);
+  ASSERT_EQ(get<1>(t2), 'a');
 }
 
 TEST(CampTuple, ForwardAsTuple)
 {
   int a, b;
-  [](camp::tuple<int &, int &, int &&> t) {
-    ASSERT_EQ(camp::get<2>(t), 5);
-    camp::get<1>(t) = 3;
-    camp::get<2>(t) = 3;
-    ASSERT_EQ(camp::get<1>(t), 3);
-    ASSERT_EQ(camp::get<2>(t), 3);
-  }(camp::forward_as_tuple(a, b, int{5}));
+  [](tuple<int &, int &, int &&> t) {
+    ASSERT_EQ(get<2>(t), 5);
+    get<1>(t) = 3;
+    get<2>(t) = 3;
+    ASSERT_EQ(get<1>(t), 3);
+    ASSERT_EQ(get<2>(t), 3);
+  }(forward_as_tuple(a, b, int{5}));
 }
 
 TEST(CampTuple, GetByIndex)
 {
-  camp::tuple<int, char> t(5, 'a');
-  ASSERT_EQ(camp::get<0>(t), 5);
-  ASSERT_EQ(camp::get<1>(t), 'a');
+  tuple<int, char> t(5, 'a');
+  ASSERT_EQ(get<0>(t), 5);
+  ASSERT_EQ(get<1>(t), 'a');
 }
 
 TEST(CampTuple, GetByType)
 {
-  camp::tuple<int, char> t(5, 'a');
-  ASSERT_EQ(camp::get<int>(t), 5);
-  ASSERT_EQ(camp::get<char>(t), 'a');
+  tuple<int, char> t(5, 'a');
+  ASSERT_EQ(get<int>(t), 5);
+  ASSERT_EQ(get<char>(t), 'a');
 }
 
 TEST(CampTuple, CatPair)
 {
-  auto t1 = camp::make_tuple(5, 'a');
-  auto t2 = camp::make_tuple(5.1f, "meh");
+  auto t1 = make_tuple(5, 'a');
+  auto t2 = make_tuple(5.1f, "meh");
   auto t3 = tuple_cat_pair(t1,
-                           camp::make_idx_seq_t<2>{},
+                           make_idx_seq_t<2>{},
                            t2,
-                           camp::make_idx_seq_t<2>{});
-  ASSERT_EQ(camp::get<1>(t3), 'a');
-  ASSERT_EQ(camp::get<2>(t3), 5.1f);
+                           make_idx_seq_t<2>{});
+  ASSERT_EQ(get<1>(t3), 'a');
+  ASSERT_EQ(get<2>(t3), 5.1f);
 
   auto t4 = tuple_cat_pair(t1, t2);
 
-  ASSERT_EQ(camp::get<1>(t4), 'a');
-  ASSERT_EQ(camp::get<2>(t4), 5.1f);
+  ASSERT_EQ(get<1>(t4), 'a');
+  ASSERT_EQ(get<2>(t4), 5.1f);
 
   auto t5 =
-      tuple_cat_pair(t1, camp::idx_seq<1, 0>{}, t2, camp::idx_seq<1, 0>{});
-  ASSERT_EQ(camp::get<0>(t5), 'a');
-  ASSERT_EQ(camp::get<3>(t5), 5.1f);
+      tuple_cat_pair(t1, idx_seq<1, 0>{}, t2, idx_seq<1, 0>{});
+  ASSERT_EQ(get<0>(t5), 'a');
+  ASSERT_EQ(get<3>(t5), 5.1f);
 }
 
 struct NoDefCon {
@@ -98,7 +100,7 @@ struct NoDefCon {
 
 TEST(CampTuple, NoDefault)
 {
-  camp::tuple<NoDefCon> t(NoDefCon(1));
+  tuple<NoDefCon> t(NoDefCon(1));
 }
 
 struct s1;
@@ -107,18 +109,18 @@ struct s3;
 
 TEST(CampTaggedTuple, GetByType)
 {
-  camp::tagged_tuple<camp::list<s1, s2>, int, char> t(5, 'a');
-  ASSERT_EQ(camp::get<s1>(t), 5);
-  ASSERT_EQ(camp::get<s2>(t), 'a');
-  camp::get<s1>(t) = 15;
-  ASSERT_EQ(camp::get<s1>(t), 15);
+  tagged_tuple<list<s1, s2>, int, char> t(5, 'a');
+  ASSERT_EQ(get<s1>(t), 5);
+  ASSERT_EQ(get<s2>(t), 'a');
+  get<s1>(t) = 15;
+  ASSERT_EQ(get<s1>(t), 15);
 }
 
 TEST(CampTaggedTuple, MakeTagged)
 {
-  auto t = camp::make_tagged_tuple<camp::list<s1, s2>>(5, 'a');
-  ASSERT_EQ(camp::get<s1>(t), 5);
-  ASSERT_EQ(camp::get<s2>(t), 'a');
-  camp::get<s1>(t) = 15;
-  ASSERT_EQ(camp::get<s1>(t), 15);
+  auto t = make_tagged_tuple<list<s1, s2>>(5, 'a');
+  ASSERT_EQ(get<s1>(t), 5);
+  ASSERT_EQ(get<s2>(t), 'a');
+  get<s1>(t) = 15;
+  ASSERT_EQ(get<s1>(t), 15);
 }

From e12f7492cd67cfcda50cc786132fb2ac736fcc3a Mon Sep 17 00:00:00 2001
From: Tom Scogland <scogland1@llnl.gov>
Date: Thu, 14 Nov 2019 17:05:53 -0800
Subject: [PATCH 10/19] fix tests in default build config

---
 CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index ff477b58..7662679d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -77,6 +77,7 @@ install(DIRECTORY
   DESTINATION
   include)
 
+SET(ENABLE_TESTS On CACHE BOOL "Test variable defaulting to '0'")
 if(ENABLE_TESTS)
 enable_testing()
 add_subdirectory(test)

From dc91e46e6f19627fe98cf4e5411e3f5932096fce Mon Sep 17 00:00:00 2001
From: Tom Scogland <scogland1@llnl.gov>
Date: Fri, 15 Nov 2019 11:55:01 -0800
Subject: [PATCH 11/19] optimize all_of, tuple instantiation 4x faster

In C++17 mode use built-in fold expressions, in 14 use a simpler type.
When in 14 mode this buys up to 30% improvement, in 17 mode it's almost
four *times* faster to instantiate tuples now.  Should help with RAJA
compile times where 17 is available.
---
 include/camp/defines.hpp   |  4 ++++
 include/camp/list/list.hpp | 17 ++++++++++++++---
 2 files changed, 18 insertions(+), 3 deletions(-)

diff --git a/include/camp/defines.hpp b/include/camp/defines.hpp
index 6f9e38b5..d9afb561 100644
--- a/include/camp/defines.hpp
+++ b/include/camp/defines.hpp
@@ -85,10 +85,14 @@ namespace camp
 #endif
 #endif
 
+#if defined(__cpp_fold_expressions) && __cpp_fold_expressions >= 201603
+#define CAMP_HAS_FOLD_EXPRESSIONS 1
+#endif
 
 #if defined(__cpp_variable_templates) && __cpp_variable_templates >= 201304
 #define CAMP_HAS_VARIABLE_TEMPLATES 1
 #endif
+
 #if defined(__cpp_inline_variables)
 #define CAMP_HAS_INLINE_VARIABLE 1
 #define CAMP_INLINE_VARIABLE inline
diff --git a/include/camp/list/list.hpp b/include/camp/list/list.hpp
index e08f2fdc..6454ba52 100644
--- a/include/camp/list/list.hpp
+++ b/include/camp/list/list.hpp
@@ -52,15 +52,26 @@ struct size<list<Args...>> {
 };
 
 /// all_of metafunction of a value type list -- all must be "true"
+#if defined(CAMP_HAS_FOLD_EXPRESSIONS)
 template <bool... Bs>
-struct all_of : is_same<list<t, num<Bs>...>, list<num<Bs>..., t>> {
+struct all_of : num<(... && Bs)> {
 };
+#else
+template <bool... Bs>
+struct all_of : is_same<int_seq<bool, true, Bs...>, int_seq<bool, Bs..., true>> {
+};
+#endif
 
 /// none_of metafunction of a value type list -- all must be "false"
+#if defined(CAMP_HAS_FOLD_EXPRESSIONS)
+template <bool... Bs>
+struct none_of : num<!(... || Bs)> {
+};
+#else
 template <bool... Bs>
-struct none_of
-    : is_same<idx_seq<false, Bs...>, idx_seq<Bs..., false>> {
+struct none_of : is_same<int_seq<bool, false, Bs...>, int_seq<bool, Bs..., false>> {
 };
+#endif
 
 /// any_of metafunction of a value type list -- at least one must be "true""
 template <bool... Bs>

From 51e66d98c75fe905906f1d20774904540a8d9757 Mon Sep 17 00:00:00 2001
From: Tom Scogland <scogland1@llnl.gov>
Date: Fri, 15 Nov 2019 16:29:46 -0800
Subject: [PATCH 12/19] more tuple compilation time enhancement

Turn tuple_storage into an aggregate when possible, turns out this is
not possible on nvcc right now, but elsewhere it's a nice little 5-20%
bump.
---
 include/camp/tuple.hpp | 61 ++++++++++++++++++++++--------------------
 test/tuple.cpp         |  9 +++++++
 2 files changed, 41 insertions(+), 29 deletions(-)

diff --git a/include/camp/tuple.hpp b/include/camp/tuple.hpp
index 561c1adf..e8bde1e3 100644
--- a/include/camp/tuple.hpp
+++ b/include/camp/tuple.hpp
@@ -87,6 +87,9 @@ namespace internal
 {
   template <camp::idx_t index, typename Type>
   struct tuple_storage {
+#if defined(__NVCC__)
+    // NVCC up until at least 10.1 can't do aggregate initialization of a pack
+    // of base classes, keep this around until that's fixed
     CAMP_HOST_DEVICE constexpr tuple_storage() : val(){};
 
     /* Workaround for bug in hipcc compiler */
@@ -105,15 +108,8 @@ namespace internal
         : val(std::forward<T>(v))
     {
     }
+#endif
 
-    CAMP_HOST_DEVICE constexpr const Type& get_inner() const noexcept
-    {
-      return val;
-    }
-
-    CAMP_HOST_DEVICE CAMP_CONSTEXPR14 Type& get_inner() noexcept { return val; }
-
-  public:
     Type val;
   };
 
@@ -122,16 +118,26 @@ namespace internal
 
   template <typename... Types, camp::idx_t... Indices>
   struct tuple_helper<camp::idx_seq<Indices...>, camp::list<Types...>>
-      : public internal::tuple_storage<Indices, Types>... {
+      : public tuple_storage<Indices, Types>... {
+
+#if !defined(__NVCC__)
+    constexpr tuple_helper() = default;
+    constexpr tuple_helper(tuple_helper const&) = default;
+    constexpr tuple_helper(tuple_helper&&) = default;
+
+#else
+    // NOTE: this is to work around nvcc 9 series issues with incorrect
+    // creation of defaulted constructors
     template <
         bool B = all_of<std::is_default_constructible<Types>::value...>::value,
         typename std::enable_if<B, void>::type* = nullptr>
     CAMP_HOST_DEVICE constexpr tuple_helper()
+        : tuple_storage<Indices, Types>()...
     {
     }
     CAMP_HOST_DEVICE constexpr tuple_helper(tuple_helper const& rhs)
         : tuple_storage<Indices, Types>(
-            rhs.tuple_storage<Indices, Types>::get_inner())...
+            rhs.tuple_storage<Indices, Types>::val)...
     {
     }
     CAMP_HOST_DEVICE constexpr tuple_helper(tuple_helper&& rhs)
@@ -139,6 +145,7 @@ namespace internal
             std::forward<Types>(rhs.tuple_storage<Indices, Types>::val))...
     {
     }
+#endif
 
     /* Workaround for bug in hipcc compiler */
     //  This likely causes issues when building with hip
@@ -152,7 +159,7 @@ namespace internal
 
     template <typename... Args>
     CAMP_HOST_DEVICE constexpr tuple_helper(Args&&... args)
-        : tuple_storage<Indices, Types>(std::forward<Args>(args))...
+        : tuple_storage<Indices, Types>{std::forward<Args>(args)}...
     {
     }
 
@@ -162,7 +169,7 @@ namespace internal
     template <typename RTuple>
     CAMP_HOST_DEVICE tuple_helper& operator=(const RTuple& rhs)
     {
-      return (camp::sink((this->tuple_storage<Indices, Types>::get_inner() =
+      return (camp::sink((this->tuple_storage<Indices, Types>::val =
                               get<Indices>(rhs))...),
               *this);
     }
@@ -220,12 +227,11 @@ struct tuple {
       -> tuple_ebt_t<T, Tuple>&;
 
 public:
-  // NOTE: __host__ __device__ on constructors causes warnings, and nothing else
-  // Constructors
-  template <
-      bool B = all_of<std::is_default_constructible<Elements>::value...>::value,
-      typename std::enable_if<B, void>::type* = nullptr>
-  CAMP_HOST_DEVICE constexpr tuple() : base()
+  // NOTE: __host__ __device__ on constructors causes warnings, and nothing
+  // else Constructors
+  template <bool B = std::is_default_constructible<Base>::value,
+            typename std::enable_if<B, void>::type* = nullptr>
+  CAMP_HOST_DEVICE constexpr tuple() : base{}
   {
   }
 
@@ -314,11 +320,10 @@ class tagged_tuple : public tuple<Elements...>
 
 
 public:
-  // NOTE: __host__ __device__ on constructors causes warnings, and nothing else
-  // Constructors
-  template <
-      bool B = all_of<std::is_default_constructible<Elements>::value...>::value,
-      typename std::enable_if<B, void>::type* = nullptr>
+  // NOTE: __host__ __device__ on constructors causes warnings, and nothing
+  // else Constructors
+  template <bool B = std::is_default_constructible<Base>::value,
+            typename std::enable_if<B, void>::type* = nullptr>
   CAMP_HOST_DEVICE constexpr tagged_tuple() : base()
   {
   }
@@ -375,7 +380,7 @@ CAMP_HOST_DEVICE constexpr auto get(const Tuple& t) noexcept
 {
   using internal::tpl_get_store;
   static_assert(tuple_size<Tuple>::value > index, "index out of range");
-  return static_cast<tpl_get_store<Tuple, index> const&>(t.base).get_inner();
+  return static_cast<tpl_get_store<Tuple, index> const&>(t.base).val;
 }
 
 template <camp::idx_t index, class Tuple>
@@ -384,7 +389,7 @@ CAMP_HOST_DEVICE constexpr auto get(Tuple& t) noexcept
 {
   using internal::tpl_get_store;
   static_assert(tuple_size<Tuple>::value > index, "index out of range");
-  return static_cast<tpl_get_store<Tuple, index>&>(t.base).get_inner();
+  return static_cast<tpl_get_store<Tuple, index>&>(t.base).val;
 }
 
 // by type
@@ -397,8 +402,7 @@ CAMP_HOST_DEVICE constexpr auto get(const Tuple& t) noexcept
   static_assert(!std::is_same<camp::nil, index_type>::value,
                 "invalid type index");
 
-  return static_cast<tpl_get_store<Tuple, index_type::value>&>(t.base)
-      .get_inner();
+  return static_cast<tpl_get_store<Tuple, index_type::value>&>(t.base).val;
 }
 
 template <typename T, class Tuple>
@@ -409,8 +413,7 @@ CAMP_HOST_DEVICE constexpr auto get(Tuple& t) noexcept -> tuple_ebt_t<T, Tuple>&
   static_assert(!std::is_same<camp::nil, index_type>::value,
                 "invalid type index");
 
-  return static_cast<tpl_get_store<Tuple, index_type::value>&>(t.base)
-      .get_inner();
+  return static_cast<tpl_get_store<Tuple, index_type::value>&>(t.base).val;
 }
 
 template <typename... Args>
diff --git a/test/tuple.cpp b/test/tuple.cpp
index 3c65ff1a..3db02c4a 100644
--- a/test/tuple.cpp
+++ b/test/tuple.cpp
@@ -90,6 +90,15 @@ TEST(CampTuple, CatPair)
   ASSERT_EQ(get<3>(t5), 5.1f);
 }
 
+TEST(CampTuple, Default)
+{
+  tuple<int, float> t;
+  auto t1 = tuple<int, float>{};
+  auto t2 = tuple<int, float>();
+  t = t1;
+  t1 = t2;
+}
+
 struct NoDefCon {
   NoDefCon() = delete;
   NoDefCon(int i) : num{i} {(void)num;}

From 28597de3075464c793b3171ddea3b85a2f53d9ee Mon Sep 17 00:00:00 2001
From: Tom Scogland <scogland1@llnl.gov>
Date: Wed, 20 Nov 2019 07:53:36 -0800
Subject: [PATCH 13/19] fix tuple_helper constructors across nvcc and hip

---
 include/camp/tuple.hpp | 46 ++++++++++++++++++++++++++----------------
 1 file changed, 29 insertions(+), 17 deletions(-)

diff --git a/include/camp/tuple.hpp b/include/camp/tuple.hpp
index e8bde1e3..ce5a563d 100644
--- a/include/camp/tuple.hpp
+++ b/include/camp/tuple.hpp
@@ -125,6 +125,25 @@ namespace internal
     constexpr tuple_helper(tuple_helper const&) = default;
     constexpr tuple_helper(tuple_helper&&) = default;
 
+    template <typename... Args>
+    CAMP_HOST_DEVICE constexpr tuple_helper(Args&&... args)
+        : tuple_storage<Indices, Types>{std::forward<Args>(args)}...
+    {
+    }
+
+    /* Workaround for bug in hipcc compiler */
+    //  This likely causes issues when building with hip
+    //  and using tuples in host code. Will be patched in the future
+#if defined(__HIPCC__) && !defined(__HIP_DEVICE_COMPILE__)
+    CAMP_HOST_DEVICE constexpr tuple_helper(Types... args)
+        : tuple_storage<Indices, Types>(args)...
+    {
+    }
+#endif
+
+    CAMP_HOST_DEVICE
+    tuple_helper& operator=(const tuple_helper& rhs) = default;
+
 #else
     // NOTE: this is to work around nvcc 9 series issues with incorrect
     // creation of defaulted constructors
@@ -145,26 +164,21 @@ namespace internal
             std::forward<Types>(rhs.tuple_storage<Indices, Types>::val))...
     {
     }
-#endif
-
-    /* Workaround for bug in hipcc compiler */
-    //  This likely causes issues when building with hip
-    //  and using tuples in host code. Will be patched in the future
-#if defined(__HIPCC__) && !defined(__HIP_DEVICE_COMPILE__)
-    CAMP_HOST_DEVICE constexpr tuple_helper(Types... args)
-        : tuple_storage<Indices, Types>(args)...
+    template <typename... Args>
+    CAMP_HOST_DEVICE constexpr tuple_helper(Args&&... args)
+        : tuple_storage<Indices, Types>(std::forward<Args>(args))...
     {
     }
-#endif
 
-    template <typename... Args>
-    CAMP_HOST_DEVICE constexpr tuple_helper(Args&&... args)
-        : tuple_storage<Indices, Types>{std::forward<Args>(args)}...
+    CAMP_HOST_DEVICE
+    tuple_helper& operator=(const tuple_helper& rhs)
     {
+      return (camp::sink((this->tuple_storage<Indices, Types>::val =
+                              rhs.tuple_storage<Indices, Types>::val)...),
+              *this);
     }
+#endif
 
-    CAMP_HOST_DEVICE 
-    tuple_helper& operator=(const tuple_helper& rhs) = default;
 
     template <typename RTuple>
     CAMP_HOST_DEVICE tuple_helper& operator=(const RTuple& rhs)
@@ -239,9 +253,7 @@ struct tuple {
   //  This likely causes issues when building with hip
   //  and using tuples in host code. Will be patched in the future
 #if defined(__HIPCC__) && !defined(__HIP_DEVICE_COMPILE__)
-  CAMP_HOST_DEVICE constexpr explicit tuple(Elements... vals) : base(vals...)
-  {
-  }
+  CAMP_HOST_DEVICE constexpr explicit tuple(Elements... vals) : base(vals...) {}
 #endif
 
   CAMP_HOST_DEVICE constexpr tuple(tuple const& o) : base(o.base) {}

From ed6892ca1615c437b189b325ec8793b8b3f5853b Mon Sep 17 00:00:00 2001
From: Tom Scogland <scogland1@llnl.gov>
Date: Wed, 20 Nov 2019 09:37:46 -0800
Subject: [PATCH 14/19] add invokable type trait

---
 include/camp/concepts.hpp | 67 +++++++++++++++++++++++++++++----------
 test/detect.cpp           |  8 +++++
 2 files changed, 59 insertions(+), 16 deletions(-)

diff --git a/include/camp/concepts.hpp b/include/camp/concepts.hpp
index 5f22e8ba..e2fdcde1 100644
--- a/include/camp/concepts.hpp
+++ b/include/camp/concepts.hpp
@@ -30,19 +30,25 @@ namespace concepts
   // TODO: add a proper ranges-style swap and update this
   CAMP_DEF_REQUIREMENT_T(Swappable, swap(val<T>(), val<T>()));
 
-  CAMP_DEF_REQUIREMENT_TU(LessThan, val<T>() < val<U>());
-  CAMP_DEF_REQUIREMENT_TU(GreaterThan, val<T>() > val<U>());
-  CAMP_DEF_REQUIREMENT_TU(LessEqual, val<T>() <= val<U>());
-  CAMP_DEF_REQUIREMENT_TU(GreaterEqual, val<T>() >= val<U>());
-
-  CAMP_DEF_REQUIREMENT_TU(Equality, val<T>() == val<U>());
-  CAMP_DEF_REQUIREMENT_TU(Inequality, val<T>() != val<U>());
+  CAMP_DEF_REQUIREMENT_TU(LessThan, val<T>() < val<U>(), val<U>() < val<T>());
+  CAMP_DEF_REQUIREMENT_TU(GreaterThan,
+                          val<T>() > val<U>(),
+                          val<U>() > val<T>());
+  CAMP_DEF_REQUIREMENT_TU(LessEqual,
+                          val<T>() <= val<U>(),
+                          val<U>() <= val<T>());
+  CAMP_DEF_REQUIREMENT_TU(GreaterEqual,
+                          val<T>() >= val<U>(),
+                          val<U>() >= val<T>());
+
+  CAMP_DEF_REQUIREMENT_TU(Equality, val<T>() == val<U>(), val<U>() == val<T>());
+  CAMP_DEF_REQUIREMENT_TU(Inequality,
+                          val<T>() != val<U>(),
+                          val<U>() != val<T>());
 
   CAMP_DEF_CONCEPT_TU(__Weakly_equality_comparable_with,
-                      (detect_convertible<bool, Equality, T, U>()
-                       && detect_convertible<bool, Inequality, T, U>()
-                       && detect_convertible<bool, Equality, U, T>()
-                       && detect_convertible<bool, Inequality, U, T>()));
+                      detect_convertible<bool, Equality, T, U>()
+                          && detect_convertible<bool, Inequality, T, U>());
 
   CAMP_DEF_CONCEPT_AND_TRAITS_T(equality_comparable,
                                 is_equality_comparable,
@@ -63,11 +69,7 @@ namespace concepts
           && detect_convertible<bool, LessThan, T, U>()
           && detect_convertible<bool, GreaterThan, T, U>()
           && detect_convertible<bool, LessEqual, T, U>()
-          && detect_convertible<bool, GreaterEqual, T, U>()
-          && detect_convertible<bool, LessThan, U, T>()
-          && detect_convertible<bool, GreaterThan, U, T>()
-          && detect_convertible<bool, LessEqual, U, T>()
-          && detect_convertible<bool, GreaterEqual, U, T>());
+          && detect_convertible<bool, GreaterEqual, T, U>());
 
   CAMP_DEF_CONCEPT_AND_TRAITS_T(comparable,
                                 is_comparable,
@@ -181,6 +183,39 @@ namespace concepts
                                     && CAMP_REQ(random_access_iterator,
                                                 iterator_from<T>));
 
+  // namespace internal
+  // {
+  //   template <typename Fn, typename Void, typename... Args>
+  //   struct invokable;
+  //   template <typename Fn, typename... Args>
+  //   struct invokable<Fn, <(decltype(Fn(val<Args>()...)), true), void>,
+  //   Args...> {
+  //   };
+  //
+  // }  // namespace internal
+
+  namespace internal
+  {
+    template <typename Fn, typename Void = void, typename... Args>
+    struct invokable : false_type {
+      using ret = detail::nonesuch;
+    };
+    template <typename Fn, typename... Args>
+    struct invokable<Fn,
+                     typename void_t<decltype(val<Fn>()(val<Args>()...))>::type,
+                     Args...> : true_type {
+      using ret = decltype(val<Fn>()(val<Args>()...));
+    };
+  }  // namespace internal
+
+  template <typename Fn, typename... Args>
+  using invokable = internal::invokable<Fn, void, Args...>;
+
+  template <typename Fn, typename Ret, typename... Args>
+  using invokable_returns =
+      is_same_t<typename internal::invokable<Fn, void, Args...>::ret, Ret>;
+
+
 
 }  // end namespace concepts
 
diff --git a/test/detect.cpp b/test/detect.cpp
index b9f30c79..20ddc81c 100644
--- a/test/detect.cpp
+++ b/test/detect.cpp
@@ -68,6 +68,13 @@ static_assert(CAMP_REQ(concepts::random_access_iterator, decltype(val<std::vecto
 static_assert(!CAMP_REQ(concepts::random_access_range, decltype(val<std::list<int>>())), "list iterator is not random access");
 static_assert(CAMP_REQ(concepts::random_access_range, decltype(val<std::vector<int>>())), "int* is an iterator");
 
+void bah (int, float);
+CAMP_CHECK_VALUE_NOT(camp::concepts::invokable<decltype(bah), int, char*>);
+CAMP_CHECK_VALUE(camp::concepts::invokable<decltype(bah), int, float>);
+CAMP_CHECK_VALUE_NOT(camp::concepts::invokable_returns<decltype(bah), void, int, char*>);
+CAMP_CHECK_VALUE(camp::concepts::invokable_returns<decltype(bah), void, int, float>);
+CAMP_CHECK_VALUE_NOT(camp::concepts::invokable_returns<decltype(bah), int, int, float>);
+
 struct TC1 {
   using my_member_type = C;
 
@@ -179,3 +186,4 @@ CAMP_CHECK_VALUE(
         TC1,
         OuterClass<C>::template _overload_nested_dependent_type_archetype,
         TC1>);
+

From cb60365191d9a0a26a24f9f6220b073b43d51516 Mon Sep 17 00:00:00 2001
From: Tom Scogland <scogland1@llnl.gov>
Date: Wed, 20 Nov 2019 11:42:32 -0800
Subject: [PATCH 15/19] add requirement/enable_if macro

---
 include/camp/concepts.hpp           | 195 +++++++++++++---------------
 include/camp/defines.hpp            |   4 +
 include/camp/type_traits/detect.hpp |  25 +++-
 3 files changed, 116 insertions(+), 108 deletions(-)

diff --git a/include/camp/concepts.hpp b/include/camp/concepts.hpp
index e2fdcde1..93d92c55 100644
--- a/include/camp/concepts.hpp
+++ b/include/camp/concepts.hpp
@@ -26,93 +26,74 @@ namespace camp
 {
 namespace concepts
 {
+  namespace internal
+  {
+    CAMP_DEF_REQUIREMENT_TU(LessThan, val<T>() < val<U>());
+    CAMP_DEF_REQUIREMENT_TU(GreaterThan, val<T>() > val<U>());
+    CAMP_DEF_REQUIREMENT_TU(LessEqual, val<T>() <= val<U>());
+    CAMP_DEF_REQUIREMENT_TU(GreaterEqual, val<T>() >= val<U>());
+
+    CAMP_DEF_REQUIREMENT_TU(Equality, val<T>() == val<U>());
+    CAMP_DEF_REQUIREMENT_TU(Inequality, val<T>() != val<U>());
+
+    CAMP_DEF_CONCEPT_TU(__Weakly_equality_comparable_with,
+                        detect_convertible<bool, Equality, T, U>()
+                            && detect_convertible<bool, Inequality, T, U>()
+                            && detect_convertible<bool, Equality, U, T>()
+                            && detect_convertible<bool, Inequality, U, T>());
+
+  }  // namespace internal
+
+  CAMP_DEF_CONCEPT_T(equality_comparable,
+                     CAMP_REQ(internal::__Weakly_equality_comparable_with,
+                              T,
+                              T));
 
-  // TODO: add a proper ranges-style swap and update this
-  CAMP_DEF_REQUIREMENT_T(Swappable, swap(val<T>(), val<T>()));
-
-  CAMP_DEF_REQUIREMENT_TU(LessThan, val<T>() < val<U>(), val<U>() < val<T>());
-  CAMP_DEF_REQUIREMENT_TU(GreaterThan,
-                          val<T>() > val<U>(),
-                          val<U>() > val<T>());
-  CAMP_DEF_REQUIREMENT_TU(LessEqual,
-                          val<T>() <= val<U>(),
-                          val<U>() <= val<T>());
-  CAMP_DEF_REQUIREMENT_TU(GreaterEqual,
-                          val<T>() >= val<U>(),
-                          val<U>() >= val<T>());
-
-  CAMP_DEF_REQUIREMENT_TU(Equality, val<T>() == val<U>(), val<U>() == val<T>());
-  CAMP_DEF_REQUIREMENT_TU(Inequality,
-                          val<T>() != val<U>(),
-                          val<U>() != val<T>());
-
-  CAMP_DEF_CONCEPT_TU(__Weakly_equality_comparable_with,
-                      detect_convertible<bool, Equality, T, U>()
-                          && detect_convertible<bool, Inequality, T, U>());
-
-  CAMP_DEF_CONCEPT_AND_TRAITS_T(equality_comparable,
-                                is_equality_comparable,
-                                CAMP_REQ(__Weakly_equality_comparable_with,
-                                         T,
-                                         T));
-
-  CAMP_DEF_CONCEPT_AND_TRAITS_TU(
+  CAMP_DEF_CONCEPT_TU(
       equality_comparable_with,
-      is_equality_comparable_with,
       CAMP_REQ(equality_comparable, T) && CAMP_REQ(equality_comparable, U)
-          && CAMP_REQ(__Weakly_equality_comparable_with, T, U));
+          && CAMP_REQ(internal::__Weakly_equality_comparable_with, T, U));
 
-  CAMP_DEF_CONCEPT_AND_TRAITS_TU(
+  CAMP_DEF_CONCEPT_TU(
       comparable_with,
-      is_comparable_with,
       CAMP_REQ(equality_comparable_with, T, U)
-          && detect_convertible<bool, LessThan, T, U>()
-          && detect_convertible<bool, GreaterThan, T, U>()
-          && detect_convertible<bool, LessEqual, T, U>()
-          && detect_convertible<bool, GreaterEqual, T, U>());
-
-  CAMP_DEF_CONCEPT_AND_TRAITS_T(comparable,
-                                is_comparable,
-                                CAMP_REQ(comparable_with, T, T));
-
-  CAMP_DEF_CONCEPT_AND_TRAITS_T(arithmetic,
-                                is_arithmetic,
-                                std::is_arithmetic<T>::value);
-  CAMP_DEF_CONCEPT_AND_TRAITS_T(floating_point,
-                                is_floating_point,
-                                std::is_floating_point<T>::value);
-  CAMP_DEF_CONCEPT_AND_TRAITS_T(integral,
-                                is_integral,
-                                std::is_integral<T>::value);
-  CAMP_DEF_CONCEPT_AND_TRAITS_T(Signed, is_signed, std::is_signed<T>::value);
-  CAMP_DEF_CONCEPT_AND_TRAITS_T(Unsigned,
-                                is_unsigned,
-                                std::is_unsigned<T>::value);
+          && detect_convertible<bool, internal::LessThan, T, U>()
+          && detect_convertible<bool, internal::GreaterThan, T, U>()
+          && detect_convertible<bool, internal::LessEqual, T, U>()
+          && detect_convertible<bool, internal::GreaterEqual, T, U>()
+          && detect_convertible<bool, internal::LessThan, U, T>()
+          && detect_convertible<bool, internal::GreaterThan, U, T>()
+          && detect_convertible<bool, internal::LessEqual, U, T>()
+          && detect_convertible<bool, internal::GreaterEqual, U, T>());
+
+  CAMP_DEF_CONCEPT_T(comparable, CAMP_REQ(comparable_with, T, T));
+
+  CAMP_DEF_CONCEPT_T(arithmetic, std::is_arithmetic<T>::value);
+  CAMP_DEF_CONCEPT_T(floating_point, std::is_floating_point<T>::value);
+  CAMP_DEF_CONCEPT_T(integral, std::is_integral<T>::value);
+  CAMP_DEF_CONCEPT_T(signed_, std::is_signed<T>::value);
+  CAMP_DEF_CONCEPT_T(unsigned_, std::is_unsigned<T>::value);
 
   CAMP_DEF_REQUIREMENT_T(Dereference, *(val<T>()));
   CAMP_DEF_REQUIREMENT_T(IncrementPre, ++val<T>());
-  CAMP_DEF_CONCEPT_AND_TRAITS_T(iterator,
-                                is_iterator,
-                                detect<Dereference, T>()
-                                    && detect_exact<T &, IncrementPre, T &>());
+  CAMP_DEF_CONCEPT_T(iterator,
+                     detect<Dereference, T>()
+                         && detect_exact<T &, IncrementPre, T &>());
 
   CAMP_DEF_REQUIREMENT_T(IncrementPost, val<T>()++);
   CAMP_DEF_REQUIREMENT_T(DereferenceIncrementPost, *val<T>()++);
-  CAMP_DEF_CONCEPT_AND_TRAITS_T(forward_iterator,
-                                is_forward_iterator,
-                                CAMP_REQ(iterator, T)
-                                    && detect<IncrementPost, T &>()
-                                    && detect<DereferenceIncrementPost, T &>());
+  CAMP_DEF_CONCEPT_T(forward_iterator,
+                     CAMP_REQ(iterator, T) && detect<IncrementPost, T &>()
+                         && detect<DereferenceIncrementPost, T &>());
 
   CAMP_DEF_REQUIREMENT_T(DecrementPre, --val<T>());
   CAMP_DEF_REQUIREMENT_T(DecrementPost, val<T>()--);
   CAMP_DEF_REQUIREMENT_T(DereferenceDecrementPost, *val<T>()--);
-  CAMP_DEF_CONCEPT_AND_TRAITS_T(
-      bidirectional_iterator,
-      is_bidirectional_iterator,
-      CAMP_REQ(forward_iterator, T) && detect_exact<T &, DecrementPre, T &>()
-          && detect_convertible<T const &, DecrementPost, T &>()
-          && detect<DereferenceDecrementPost, T &>());
+  CAMP_DEF_CONCEPT_T(bidirectional_iterator,
+                     CAMP_REQ(forward_iterator, T)
+                         && detect_exact<T &, DecrementPre, T &>()
+                         && detect_convertible<T const &, DecrementPost, T &>()
+                         && detect<DereferenceDecrementPost, T &>());
 
   CAMP_DEF_REQUIREMENT_T(MemberDifferenceType, T::difference_type);
   CAMP_DEF_REQUIREMENT_TU(PlusEq, val<T>() += val<U>());
@@ -120,6 +101,7 @@ namespace concepts
   CAMP_DEF_REQUIREMENT_TU(SubEq, val<T>() -= val<U>());
   CAMP_DEF_REQUIREMENT_TU(Sub, val<T>() - val<U>());
   CAMP_DEF_REQUIREMENT_TU(Index, val<T>()[val<U>()]);
+
   template <class I, typename = void>
   struct incrementable_traits {
   };
@@ -156,43 +138,27 @@ namespace concepts
   CAMP_DEF_REQUIREMENT_T(DiffSubIt, val<difft_from<T>>() - val<T>());
   CAMP_DEF_REQUIREMENT_T(IndexDiff, val<T>()[val<difft_from<T>>()]);
 
-  CAMP_DEF_CONCEPT_AND_TRAITS_T(random_access_iterator,
-                                is_random_access_iterator,
-                                CAMP_REQ(bidirectional_iterator, T)
-                                    && CAMP_REQ(comparable, T)
-                                    && detect_exact<T &, ItPlusEqDiff, T &>()
-                                    && detect_exact<T, ItPlusDiff, T>()
-                                    && detect_exact<T, DiffPlusIt, T>()
-                                    && detect_exact<T &, ItSubEqDiff, T &>()
-                                    && detect_exact<T, ItSubDiff, T>()
-                                    && detect<IndexDiff, T>());
+  CAMP_DEF_CONCEPT_T(random_access_iterator,
+                     CAMP_REQ(bidirectional_iterator, T)
+                         && CAMP_REQ(comparable, T)
+                         && detect_exact<T &, ItPlusEqDiff, T &>()
+                         && detect_exact<T, ItPlusDiff, T>()
+                         && detect_exact<T, DiffPlusIt, T>()
+                         && detect_exact<T &, ItSubEqDiff, T &>()
+                         && detect_exact<T, ItSubDiff, T>()
+                         && detect<IndexDiff, T>());
 
   CAMP_DEF_REQUIREMENT_T(BeginMember, val<T>().begin());
   CAMP_DEF_REQUIREMENT_T(BeginFree, begin(val<T>()));
   CAMP_DEF_REQUIREMENT_T(EndMember, val<T>().end());
   CAMP_DEF_REQUIREMENT_T(EndFree, end(val<T>()));
-  CAMP_DEF_CONCEPT_AND_TRAITS_T(
-      has_begin_end,
-      trait_has_begin_end,
-      (detect<BeginMember, T>() || detect<BeginFree>())
-          && (detect<EndMember, T>() || detect<EndFree>()));
-
-  CAMP_DEF_CONCEPT_AND_TRAITS_T(random_access_range,
-                                is_random_access_range,
-                                CAMP_REQ(has_begin_end, T)
-                                    && CAMP_REQ(random_access_iterator,
-                                                iterator_from<T>));
-
-  // namespace internal
-  // {
-  //   template <typename Fn, typename Void, typename... Args>
-  //   struct invokable;
-  //   template <typename Fn, typename... Args>
-  //   struct invokable<Fn, <(decltype(Fn(val<Args>()...)), true), void>,
-  //   Args...> {
-  //   };
-  //
-  // }  // namespace internal
+  CAMP_DEF_CONCEPT_T(has_begin_end,
+                     (detect<BeginMember, T>() || detect<BeginFree>())
+                         && (detect<EndMember, T>() || detect<EndFree>()));
+
+  CAMP_DEF_CONCEPT_T(random_access_range,
+                     CAMP_REQ(has_begin_end, T)
+                         && CAMP_REQ(random_access_iterator, iterator_from<T>));
 
   namespace internal
   {
@@ -216,7 +182,6 @@ namespace concepts
       is_same_t<typename internal::invokable<Fn, void, Args...>::ret, Ret>;
 
 
-
 }  // end namespace concepts
 
 namespace type_traits
@@ -280,6 +245,28 @@ namespace type_traits
                                  IsSpecialized<Expected, Args...>::value,
                                  Args...> {
   };
+  CAMP_TYPE_TRAITS_FROM_CONCEPT(concepts::equality_comparable,
+                                is_equality_comparable);
+  CAMP_TYPE_TRAITS_FROM_CONCEPT(concepts::equality_comparable_with,
+                                is_equality_comparable_with);
+
+  CAMP_TYPE_TRAITS_FROM_CONCEPT(concepts::comparable_with, is_comparable_with);
+  CAMP_TYPE_TRAITS_FROM_CONCEPT(concepts::comparable, is_comparable);
+  CAMP_TYPE_TRAITS_FROM_CONCEPT(concepts::arithmetic, is_arithmetic);
+  CAMP_TYPE_TRAITS_FROM_CONCEPT(concepts::floating_point, is_floating_point);
+  CAMP_TYPE_TRAITS_FROM_CONCEPT(concepts::integral, is_integral);
+  CAMP_TYPE_TRAITS_FROM_CONCEPT(concepts::signed_, is_signed);
+  CAMP_TYPE_TRAITS_FROM_CONCEPT(concepts::unsigned_, is_unsigned);
+  CAMP_TYPE_TRAITS_FROM_CONCEPT(concepts::iterator, is_iterator);
+  CAMP_TYPE_TRAITS_FROM_CONCEPT(concepts::forward_iterator,
+                                is_forward_iterator);
+  CAMP_TYPE_TRAITS_FROM_CONCEPT(concepts::bidirectional_iterator,
+                                is_bidirectional_iterator);
+  CAMP_TYPE_TRAITS_FROM_CONCEPT(concepts::random_access_iterator,
+                                is_random_access_iterator);
+  CAMP_TYPE_TRAITS_FROM_CONCEPT(concepts::has_begin_end, has_begin_end);
+  CAMP_TYPE_TRAITS_FROM_CONCEPT(concepts::random_access_range,
+                                is_random_access_range);
 
 }  // end namespace type_traits
 }  // namespace camp
diff --git a/include/camp/defines.hpp b/include/camp/defines.hpp
index d9afb561..f1171711 100644
--- a/include/camp/defines.hpp
+++ b/include/camp/defines.hpp
@@ -93,6 +93,10 @@ namespace camp
 #define CAMP_HAS_VARIABLE_TEMPLATES 1
 #endif
 
+#if defined(__cpp_concepts) && __cpp_fold_expressions >= 201507
+#define CAMP_HAS_CONCEPTS 1
+#endif
+
 #if defined(__cpp_inline_variables)
 #define CAMP_HAS_INLINE_VARIABLE 1
 #define CAMP_INLINE_VARIABLE inline
diff --git a/include/camp/type_traits/detect.hpp b/include/camp/type_traits/detect.hpp
index 01bb7689..4afd3bbd 100644
--- a/include/camp/type_traits/detect.hpp
+++ b/include/camp/type_traits/detect.hpp
@@ -6,6 +6,7 @@
 #define CAMP_DETECT_HPP
 
 #include "../number/number.hpp"
+#include "../detail/loop-macros.h"
 #include "is_convertible.hpp"
 #include "is_same.hpp"
 
@@ -17,6 +18,10 @@ template <class...>
 struct void_t {
   using type = void;
 };
+template <class First, class...>
+struct first_t {
+  using type = First;
+};
 
 namespace detail
 {
@@ -106,7 +111,7 @@ constexpr bool detect_convertible()
   using name = __Res
 
 #define CAMP_DEF_REQUIREMENT(name, params, ...) \
-  CAMP_DEF_DETECTOR(name, params, decltype((__VA_ARGS__)))
+  CAMP_DEF_DETECTOR(name, params, decltype(__VA_ARGS__))
 
 #define CAMP_DEF_REQUIREMENT_T(name, ...) \
   CAMP_DEF_REQUIREMENT(name, (class T), __VA_ARGS__)
@@ -115,17 +120,19 @@ constexpr bool detect_convertible()
   CAMP_DEF_REQUIREMENT(name, (class T, class U), __VA_ARGS__)
 
 
-#ifdef HAVE_CONCEPTS
+#ifdef CAMP_HAS_CONCEPTS
 #define CAMP_DEF_CONCEPT(name, params, ...) \
   template <CAMP_UNQUOTE params>            \
   concept name = __VA_ARGS__
 
 #define CAMP_REQ(name, ...) name<__VA_ARGS__>
+#define CAMP_REQ_BOOL(name, ...) (bool)name<__VA_ARGS__>
 #elif defined(__cpp_variable_templates) && __cpp_variable_templates >= 201304
 #define CAMP_DEF_CONCEPT(name, params, ...) \
   template <CAMP_UNQUOTE params>            \
   CAMP_INLINE_VARIABLE constexpr bool name = __VA_ARGS__
 #define CAMP_REQ(name, ...) name<__VA_ARGS__>
+#define CAMP_REQ_BOOL(name, ...) name<__VA_ARGS__>
 #else
 #define CAMP_DEF_CONCEPT(name, params, ...) \
   template <CAMP_UNQUOTE params>            \
@@ -134,6 +141,7 @@ constexpr bool detect_convertible()
     return (__VA_ARGS__);                   \
   }
 #define CAMP_REQ(name, ...) name##_c<__VA_ARGS__>()
+#define CAMP_REQ_BOOL(name, ...) name##_c<__VA_ARGS__>()
 #endif
 
 #define CAMP_DEF_CONCEPT_T(name, ...) \
@@ -144,7 +152,7 @@ constexpr bool detect_convertible()
 #if defined(CAMP_HAS_VARIABLE_TEMPLATES)
 #define CAMP_MAKE_V_FROM_CONCEPT(CONCEPT, TT) \
   template <typename... Types>                \
-  constexpr auto TT##_v = CAMP_REQ(CONCEPT, Types...)
+  constexpr auto TT##_v = CAMP_REQ_BOOL(CONCEPT, Types...)
 #else
 #define CAMP_MAKE_V_FROM_CONCEPT(X, Y)
 #endif
@@ -152,7 +160,7 @@ constexpr bool detect_convertible()
 
 #define CAMP_TYPE_TRAITS_FROM_CONCEPT(CONCEPT, TT)           \
   template <typename... Types>                               \
-  struct TT : num<CAMP_REQ(CONCEPT, Types...)> { \
+  struct TT : ::camp::num<CAMP_REQ_BOOL(CONCEPT, Types...)> { \
   };                                                         \
   template <typename... Types>                               \
   using TT##_t = typename TT<Types...>::type;          \
@@ -170,5 +178,14 @@ constexpr bool detect_convertible()
   CAMP_DEF_CONCEPT_TU(CONCEPT, __VA_ARGS__);             \
   CAMP_TYPE_TRAITS_FROM_CONCEPT(CONCEPT, TT)
 
+#ifdef CAMP_HAS_CONCEPTS
+#define CAMP_REQUIRES_RET(RET, ...) \
+  RET requires __VA_ARGS__
+#else
+#define CAMP_REQUIRES_RET(RET, ...) \
+  ::camp::enable_if_t<__VA_ARGS__, RET> 
+#endif
+
+
 }  // namespace camp
 #endif  // CAMP_DETECT_HPP

From c6b35e2ce6fa7b7495cfabd2783ea67b07f91332 Mon Sep 17 00:00:00 2001
From: Tom Scogland <scogland1@llnl.gov>
Date: Wed, 20 Nov 2019 11:43:57 -0800
Subject: [PATCH 16/19] remove loop macros header include for now

---
 include/camp/type_traits/detect.hpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/include/camp/type_traits/detect.hpp b/include/camp/type_traits/detect.hpp
index 4afd3bbd..82509076 100644
--- a/include/camp/type_traits/detect.hpp
+++ b/include/camp/type_traits/detect.hpp
@@ -6,7 +6,6 @@
 #define CAMP_DETECT_HPP
 
 #include "../number/number.hpp"
-#include "../detail/loop-macros.h"
 #include "is_convertible.hpp"
 #include "is_same.hpp"
 

From ad30597a85f7b31b3a7c451af0b0170e24e44abf Mon Sep 17 00:00:00 2001
From: Tom Scogland <scogland1@llnl.gov>
Date: Wed, 20 Nov 2019 11:59:41 -0800
Subject: [PATCH 17/19] add range concept

---
 include/camp/concepts.hpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/include/camp/concepts.hpp b/include/camp/concepts.hpp
index 93d92c55..a371aa1b 100644
--- a/include/camp/concepts.hpp
+++ b/include/camp/concepts.hpp
@@ -156,6 +156,9 @@ namespace concepts
                      (detect<BeginMember, T>() || detect<BeginFree>())
                          && (detect<EndMember, T>() || detect<EndFree>()));
 
+  CAMP_DEF_CONCEPT_T(range,
+                     CAMP_REQ(has_begin_end, T)
+                         && CAMP_REQ(iterator, iterator_from<T>));
   CAMP_DEF_CONCEPT_T(random_access_range,
                      CAMP_REQ(has_begin_end, T)
                          && CAMP_REQ(random_access_iterator, iterator_from<T>));
@@ -265,6 +268,8 @@ namespace type_traits
   CAMP_TYPE_TRAITS_FROM_CONCEPT(concepts::random_access_iterator,
                                 is_random_access_iterator);
   CAMP_TYPE_TRAITS_FROM_CONCEPT(concepts::has_begin_end, has_begin_end);
+  CAMP_TYPE_TRAITS_FROM_CONCEPT(concepts::range,
+                                is_range);
   CAMP_TYPE_TRAITS_FROM_CONCEPT(concepts::random_access_range,
                                 is_random_access_range);
 

From 3b0edd1ea2f2677890f2f52c59e9e0706480407e Mon Sep 17 00:00:00 2001
From: Tom Scogland <scogland1@llnl.gov>
Date: Wed, 20 Nov 2019 12:01:43 -0800
Subject: [PATCH 18/19] explicitly cast expression to bool

---
 include/camp/type_traits/detect.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/camp/type_traits/detect.hpp b/include/camp/type_traits/detect.hpp
index 82509076..b0f9b10b 100644
--- a/include/camp/type_traits/detect.hpp
+++ b/include/camp/type_traits/detect.hpp
@@ -182,7 +182,7 @@ constexpr bool detect_convertible()
   RET requires __VA_ARGS__
 #else
 #define CAMP_REQUIRES_RET(RET, ...) \
-  ::camp::enable_if_t<__VA_ARGS__, RET> 
+  ::camp::enable_if_t<(bool)(__VA_ARGS__), RET> 
 #endif
 
 

From f5e29cf368e90eb4051c4aa158729a78e8c3cea3 Mon Sep 17 00:00:00 2001
From: Tom Scogland <scogland1@llnl.gov>
Date: Wed, 20 Nov 2019 16:25:44 -0800
Subject: [PATCH 19/19] add index concept for indexing types

---
 include/camp/concepts.hpp | 6 ++++++
 test/detect.cpp           | 6 ++++++
 2 files changed, 12 insertions(+)

diff --git a/include/camp/concepts.hpp b/include/camp/concepts.hpp
index a371aa1b..b8b83626 100644
--- a/include/camp/concepts.hpp
+++ b/include/camp/concepts.hpp
@@ -74,6 +74,11 @@ namespace concepts
   CAMP_DEF_CONCEPT_T(signed_, std::is_signed<T>::value);
   CAMP_DEF_CONCEPT_T(unsigned_, std::is_unsigned<T>::value);
 
+  template <typename T>
+  struct is_index : false_type {
+  };
+  CAMP_DEF_CONCEPT_T(index, std::is_integral<T>::value || is_index<T>::value);
+
   CAMP_DEF_REQUIREMENT_T(Dereference, *(val<T>()));
   CAMP_DEF_REQUIREMENT_T(IncrementPre, ++val<T>());
   CAMP_DEF_CONCEPT_T(iterator,
@@ -258,6 +263,7 @@ namespace type_traits
   CAMP_TYPE_TRAITS_FROM_CONCEPT(concepts::arithmetic, is_arithmetic);
   CAMP_TYPE_TRAITS_FROM_CONCEPT(concepts::floating_point, is_floating_point);
   CAMP_TYPE_TRAITS_FROM_CONCEPT(concepts::integral, is_integral);
+  CAMP_TYPE_TRAITS_FROM_CONCEPT(concepts::index, is_index);
   CAMP_TYPE_TRAITS_FROM_CONCEPT(concepts::signed_, is_signed);
   CAMP_TYPE_TRAITS_FROM_CONCEPT(concepts::unsigned_, is_unsigned);
   CAMP_TYPE_TRAITS_FROM_CONCEPT(concepts::iterator, is_iterator);
diff --git a/test/detect.cpp b/test/detect.cpp
index 20ddc81c..21863cc4 100644
--- a/test/detect.cpp
+++ b/test/detect.cpp
@@ -36,6 +36,12 @@ static_assert(std::is_arithmetic<int>::value, "int is not arithmetic");
 static_assert(CAMP_REQ(Arith, int), "int is arithmetic");
 static_assert(is_arithmetic<int>::value, "int is arithmetic");
 static_assert(!is_arithmetic<A>::value, "A is not arithmetic");
+
+template<>
+struct type_traits::is_index<B> : true_type {};
+static_assert(type_traits::is_index<int>::value, "int is a valid indexing type");
+static_assert(!type_traits::is_index<A>::value, "A is not a valid indexing type");
+static_assert(type_traits::is_index<B>::value, "A is not a valid indexing type");
 // CAMP_CHECK_VALUE_NOT(is_detected<Arith, A>);
 // CAMP_CHECK_VALUE(is_detected<Arith, int>);
 // CAMP_CHECK_VALUE(is_detected<Arith, float>);