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/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)
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 e81852db..b8b83626 100644
--- a/include/camp/concepts.hpp
+++ b/include/camp/concepts.hpp
@@ -11,320 +11,189 @@ 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 "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/enable_if.hpp"
+#include "type_traits/is_same.hpp"
+#include "type_traits/iterator_from.hpp"
 
 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
-
-template <typename... T>
-camp::true_type ___valid_expr___(T &&...) noexcept;
-#define DefineConcept(...) decltype(___valid_expr___(__VA_ARGS__))
-
-#define DefineTypeTraitFromConcept(TTName, ConceptName)             \
-  template <typename... Args>                                       \
-  struct TTName : camp::concepts::requires_<ConceptName, Args...> { \
-  }
-namespace camp
-{
-namespace concepts
-{
-
-  namespace detail
+  namespace internal
   {
-
-    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;
-
-  }  // 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::if_<BoolLike, camp::true_type, camp::false_type>;
-
-  template <typename BoolLike>
-  constexpr auto is_not(BoolLike) noexcept
-      -> camp::if_c<!BoolLike::value, camp::true_type, camp::false_type>;
-
-  /// 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 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_ : detail::detected<Op, detail::TL<Args...>> {
-  };
-
-  template <typename T>
-  struct Swappable : DefineConcept(swap(val<T>(), val<T>())) {
-  };
-
-  template <typename T>
-  struct LessThanComparable
-      : DefineConcept(convertible_to<bool>(val<T>() < val<T>())) {
-  };
-
-  template <typename T>
-  struct GreaterThanComparable
-      : DefineConcept(convertible_to<bool>(val<T>() > val<T>())) {
-  };
-
-  template <typename T>
-  struct LessEqualComparable
-      : DefineConcept(convertible_to<bool>(val<T>() <= val<T>())) {
-  };
-
-  template <typename T>
-  struct GreaterEqualComparable
-      : DefineConcept(convertible_to<bool>(val<T>() >= val<T>())) {
-  };
-
-  template <typename T>
-  struct EqualityComparable
-      : DefineConcept(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>())) {
-  };
-
-  template <typename T>
-  struct Comparable : ComparableTo<T, T> {
-  };
-
-  template <typename T>
-  struct Arithmetic : DefineConcept(is(std::is_arithmetic<T>())) {
-  };
-
-  template <typename T>
-  struct FloatingPoint : DefineConcept(is(std::is_floating_point<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>());
+
+  }  // namespace internal
+
+  CAMP_DEF_CONCEPT_T(equality_comparable,
+                     CAMP_REQ(internal::__Weakly_equality_comparable_with,
+                              T,
+                              T));
+
+  CAMP_DEF_CONCEPT_TU(
+      equality_comparable_with,
+      CAMP_REQ(equality_comparable, T) && CAMP_REQ(equality_comparable, U)
+          && CAMP_REQ(internal::__Weakly_equality_comparable_with, T, U));
+
+  CAMP_DEF_CONCEPT_TU(
+      comparable_with,
+      CAMP_REQ(equality_comparable_with, T, U)
+          && 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);
 
   template <typename T>
-  struct Integral : DefineConcept(is(std::is_integral<T>())) {
+  struct is_index : false_type {
   };
-
-  template <typename T>
-  struct Signed : DefineConcept(Integral<T>(), is(std::is_signed<T>())) {
+  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,
+                     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_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_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>());
+  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 Unsigned : DefineConcept(Integral<T>(), is(std::is_unsigned<T>())) {
-  };
-
-  template <typename T>
-  struct Iterator
-      : DefineConcept(is_not(Integral<T>()),  // hacky NVCC 8 workaround
-                      *(val<T>()),
-                      has_type<T &>(++val<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 ForwardIterator
-      : DefineConcept(Iterator<T>(), val<T &>()++, *val<T &>()++) {
+  template <class T>
+  struct incrementable_traits<const T> : incrementable_traits<T> {
   };
-
-  template <typename T>
-  struct BidirectionalIterator
-      : DefineConcept(ForwardIterator<T>(),
-                      has_type<T &>(--val<T &>()),
-                      convertible_to<T const &>(val<T &>()--),
-                      *val<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 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 <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 HasBeginEnd : DefineConcept(std::begin(val<T>()), std::end(val<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_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_T(has_begin_end,
+                     (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>));
+
+  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 T>
-  struct Range : DefineConcept(HasBeginEnd<T>(), Iterator<iterator_from<T>>()) {
-  };
+  template <typename Fn, typename... Args>
+  using invokable = internal::invokable<Fn, void, Args...>;
 
-  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 Fn, typename Ret, typename... Args>
+  using invokable_returns =
+      is_same_t<typename internal::invokable<Fn, void, Args...>::ret, Ret>;
 
-  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>()));
@@ -341,24 +210,26 @@ 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...>> {
+        : camp::is_same<Expected<Args...>, Actual<Args...>> {
     };
     /// \endcond
 
@@ -373,7 +244,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,
@@ -381,6 +253,31 @@ 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::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);
+  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::range,
+                                is_range);
+  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 3143209b..f1171711 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
@@ -70,10 +71,37 @@ 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 defined(__HIPCC__)
-#define CAMP_HAVE_HIP
+#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_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_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
+#else
+#define CAMP_INLINE_VARIABLE
 #endif
 
 // Types
@@ -88,6 +116,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..c80c7597 100644
--- a/include/camp/helpers.hpp
+++ b/include/camp/helpers.hpp
@@ -12,36 +12,14 @@ 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
 {
 
-/// 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,33 @@ 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
+
 template <typename T>
 using decay = type::cv::rem<type::ref::rem<T>>;
 
@@ -155,8 +160,6 @@ 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>>());
 
-template <typename T>
-using iterator_from = decltype(begin(val<plain<T>>()));
 
 template <class T>
 CAMP_HOST_DEVICE constexpr T&& forward(type::ref::rem<T>& t) noexcept
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..6454ba52 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,48 @@ struct size<list<Args...>> {
   using type = num<sizeof...(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 : 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<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>
+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..ce5a563d 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
@@ -88,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 */
@@ -106,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;
   };
 
@@ -123,21 +118,16 @@ 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>
-    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())...
-    {
-    }
-    CAMP_HOST_DEVICE constexpr tuple_helper(tuple_helper&& rhs)
-        : tuple_storage<Indices, Types>(
-              std::forward<Types>(rhs.tuple_storage<Indices, Types>::val))...
+      : 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;
+
+    template <typename... Args>
+    CAMP_HOST_DEVICE constexpr tuple_helper(Args&&... args)
+        : tuple_storage<Indices, Types>{std::forward<Args>(args)}...
     {
     }
 
@@ -151,19 +141,49 @@ namespace internal
     }
 #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
+    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>::val)...
+    {
+    }
+    CAMP_HOST_DEVICE constexpr tuple_helper(tuple_helper&& rhs)
+        : tuple_storage<Indices, Types>(
+            std::forward<Types>(rhs.tuple_storage<Indices, Types>::val))...
+    {
+    }
     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) = default;
+    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
+
 
     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);
     }
@@ -221,12 +241,11 @@ struct tuple {
       -> tuple_ebt_t<T, 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,
+  // 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()
+  CAMP_HOST_DEVICE constexpr tuple() : base{}
   {
   }
 
@@ -234,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) {}
@@ -315,10 +332,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,
+  // 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()
   {
@@ -376,7 +392,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>
@@ -385,7 +401,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
@@ -398,8 +414,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>
@@ -410,8 +425,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>
@@ -513,23 +527,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/detect.hpp b/include/camp/type_traits/detect.hpp
new file mode 100644
index 00000000..b0f9b10b
--- /dev/null
+++ b/include/camp/type_traits/detect.hpp
@@ -0,0 +1,190 @@
+//
+// Created by Tom Scogland on 11/5/19.
+//
+
+#ifndef CAMP_DETECT_HPP
+#define CAMP_DETECT_HPP
+
+#include "../number/number.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;
+};
+template <class First, class...>
+struct first_t {
+  using type = First;
+};
+
+namespace detail
+{
+
+  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...>;
+  };
+
+}  // 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...>;
+
+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;
+
+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 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__> \
+  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_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 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>            \
+  constexpr bool name##_c()                 \
+  {                                         \
+    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, ...) \
+  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_BOOL(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 : ::camp::num<CAMP_REQ_BOOL(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)
+
+#ifdef CAMP_HAS_CONCEPTS
+#define CAMP_REQUIRES_RET(RET, ...) \
+  RET requires __VA_ARGS__
+#else
+#define CAMP_REQUIRES_RET(RET, ...) \
+  ::camp::enable_if_t<(bool)(__VA_ARGS__), RET> 
+#endif
+
+
+}  // namespace camp
+#endif  // CAMP_DETECT_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 */
diff --git a/include/camp/type_traits/is_convertible.hpp b/include/camp/type_traits/is_convertible.hpp
new file mode 100644
index 00000000..c9fe1f1d
--- /dev/null
+++ b/include/camp/type_traits/is_convertible.hpp
@@ -0,0 +1,37 @@
+//
+// 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 TO>
+  constexpr void test_conversion(TO) 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 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
+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/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/CMakeLists.txt b/test/CMakeLists.txt
index 4973ee9a..e595a6e2 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -111,12 +111,19 @@ 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)
 
 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/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>);
diff --git a/test/detect.cpp b/test/detect.cpp
new file mode 100644
index 00000000..21863cc4
--- /dev/null
+++ b/test/detect.cpp
@@ -0,0 +1,195 @@
+//
+// Created by Tom Scogland on 11/5/19.
+//
+
+#include <camp/detail/test.hpp>
+#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;
+
+struct A {
+};
+struct B : A {
+};
+struct C {
+};
+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");
+
+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>);
+// 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");
+
+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;
+
+  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&);
+};
+
+// 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>);
+
+//  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_REQUIREMENT_T(_my_method_archetype_1,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>);
+
diff --git a/test/tuple.cpp b/test/tuple.cpp
index f6801cff..3db02c4a 100644
--- a/test/tuple.cpp
+++ b/test/tuple.cpp
@@ -16,76 +16,87 @@
 #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);
+}
+
+TEST(CampTuple, Default)
+{
+  tuple<int, float> t;
+  auto t1 = tuple<int, float>{};
+  auto t2 = tuple<int, float>();
+  t = t1;
+  t1 = t2;
 }
 
 struct NoDefCon {
@@ -98,7 +109,7 @@ struct NoDefCon {
 
 TEST(CampTuple, NoDefault)
 {
-  camp::tuple<NoDefCon> t(NoDefCon(1));
+  tuple<NoDefCon> t(NoDefCon(1));
 }
 
 struct s1;
@@ -107,18 +118,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);
 }