diff --git a/examples/getting_started_listing_02.cpp b/examples/getting_started_listing_02.cpp
index 663b4909..bfb32e47 100644
--- a/examples/getting_started_listing_02.cpp
+++ b/examples/getting_started_listing_02.cpp
@@ -16,7 +16,7 @@ int main() {
         - in addition, the factory also accepts iterators over a sequence of
           axis::any, the polymorphic type that can hold concrete axis types
     */
-    std::vector<bh::axis::any_builtin> axes;
+    std::vector<bh::axis::any_std> axes;
     axes.emplace_back(bh::axis::category<std::string>({"red", "blue"}));
     axes.emplace_back(bh::axis::regular<>(5, -5, 5, "x"));
     axes.emplace_back(bh::axis::regular<>(5, -5, 5, "y"));
diff --git a/examples/guide_make_dynamic_histogram.cpp b/examples/guide_make_dynamic_histogram.cpp
index 603f0325..39cfb7c4 100644
--- a/examples/guide_make_dynamic_histogram.cpp
+++ b/examples/guide_make_dynamic_histogram.cpp
@@ -7,7 +7,7 @@ namespace bh = boost::histogram;
 
 int main() {
     // create vector of axes, axis::any is a polymorphic axis type
-    auto v = std::vector<bh::axis::any_builtin>();
+    auto v = std::vector<bh::axis::any_std>();
     v.push_back(bh::axis::regular<>(100, -1, 1));
     v.push_back(bh::axis::integer<>(1, 7));
 
diff --git a/include/boost/histogram/axis/any.hpp b/include/boost/histogram/axis/any.hpp
index 2302aaea..b2dd3890 100644
--- a/include/boost/histogram/axis/any.hpp
+++ b/include/boost/histogram/axis/any.hpp
@@ -32,33 +32,35 @@ namespace histogram {
 namespace axis {
 
 namespace detail {
-struct size : public static_visitor<int> {
+using ::boost::histogram::detail::rm_cv_ref;
+
+struct size_visitor : public static_visitor<int> {
   template <typename A> int operator()(const A &a) const { return a.size(); }
 };
 
-struct shape : public static_visitor<int> {
+struct shape_visitor : public static_visitor<int> {
   template <typename A> int operator()(const A &a) const { return a.shape(); }
 };
 
-struct uoflow : public static_visitor<bool> {
+struct uoflow_visitor : public static_visitor<bool> {
   template <typename A> bool operator()(const A &a) const { return a.uoflow(); }
 };
 
-struct get_label : public static_visitor<string_view> {
+struct get_label_visitor : public static_visitor<string_view> {
   template <typename A>::boost::string_view operator()(const A &a) const {
     return a.label();
   }
 };
 
-struct set_label : public static_visitor<void> {
+struct set_label_visitor : public static_visitor<void> {
   const ::boost::string_view label;
-  set_label(const ::boost::string_view x) : label(x) {}
+  set_label_visitor(const ::boost::string_view x) : label(x) {}
   template <typename A> void operator()(A &a) const { a.label(label); }
 };
 
-struct index : public static_visitor<int> {
+struct index_visitor : public static_visitor<int> {
   const double x;
-  explicit index(const double arg) : x(arg) {}
+  explicit index_visitor(const double arg) : x(arg) {}
   template <typename Axis> int operator()(const Axis &a) const {
     return impl(std::is_convertible<double, typename Axis::value_type>(), a);
   }
@@ -73,9 +75,9 @@ struct index : public static_visitor<int> {
   }
 };
 
-struct lower : public static_visitor<double> {
+struct lower_visitor : public static_visitor<double> {
   int idx;
-  lower(int i) : idx(i) {}
+  lower_visitor(int i) : idx(i) {}
   template <typename Axis> double operator()(const Axis &a) const {
     return impl(
         std::integral_constant<
@@ -96,7 +98,7 @@ struct lower : public static_visitor<double> {
   }
 };
 
-struct bicmp : public static_visitor<bool> {
+struct bicmp_visitor : public static_visitor<bool> {
   template <typename T, typename U> bool operator()(const T&, const U&) const {
     return false;
   }
@@ -106,6 +108,44 @@ struct bicmp : public static_visitor<bool> {
   }  
 };
 
+template <typename T>
+struct cmp_visitor : public static_visitor<bool> {
+  const T& t;
+  cmp_visitor(const T& tt) : t(tt) {}
+  template <typename U> bool operator()(const U& u) const {
+    return impl(mp11::mp_same<T, U>(), u);
+  }
+
+  template <typename U> bool impl(mp11::mp_true, const U& u) const {
+    return t == u;
+  }
+
+  template <typename U> bool impl(mp11::mp_false, const U&) const {
+    return false;
+  }
+};
+
+template <typename T>
+struct assign_visitor : public static_visitor<void> {
+  T& t;
+  assign_visitor(T& tt) : t(tt) {}
+  template <typename U> void operator()(const U& u) const {
+    impl(mp11::mp_contains<typename T::types, U>(), u);
+  }
+
+  template <typename U> void impl(mp11::mp_true, const U& u) const {
+    t = u;
+  }
+
+  template <typename U> void impl(mp11::mp_false, const U&) const {
+    throw std::invalid_argument(::boost::histogram::detail::cat(
+        "argument ",
+        boost::typeindex::type_id<U>().pretty_name(),
+        " is not a bounded type of ",
+        boost::typeindex::type_id<T>().pretty_name()));
+  }
+};
+
 } // namespace detail
 
 /// Polymorphic axis type
@@ -120,62 +160,60 @@ public:
   using const_reverse_iterator = reverse_iterator_over<any>;
 
 private:
-  template <typename T> using requires_bounded_type = mp11::mp_if<mp11::mp_contains<types, T>, void>;
+  template <typename T> using requires_bounded_type = mp11::mp_if<
+      mp11::mp_contains<types, detail::rm_cv_ref<T>
+    >, void>;
 
 public:
   any() = default;
   any(const any&) = default;
   any& operator=(const any&) = default;
-  // any(any&&) = default;
-  // any& operator=(any&&) = default;
-
-  template <typename... Us>
-  any(const any<Us...> &) {} // TODO
-
-  template <typename... Us>
-  any &operator=(const any<Us...> &) { // TODO
-    return *this;
-  }
+  any(any&&) = default;
+  any& operator=(any&&) = default;
 
   template <typename T, typename = requires_bounded_type<T>>
-  any(const T& ) {} // TODO
+  any(T&& t) : base_type(std::forward<T>(t)) {}
 
-  template <typename T>
-  any& operator=(const T&) {
+  template <typename T, typename = requires_bounded_type<T>>
+  any& operator=(T&& t) {
+    base_type::operator=(std::forward<T>(t));
     return *this;
   }
 
-  // template <typename... Us>
-  // any(any<Us...> &&t) {} // TODO
+  template <typename... Us>
+  any(const any<Us...> & u) {
+    apply_visitor(detail::assign_visitor<any>(*this), u);
+  }
 
-  // template <typename... Us>
-  // any &operator=(any<Us...> &&t) { // TODO
-  //   return *this;
-  // }
+  template <typename... Us>
+  any &operator=(const any<Us...> & u) {
+    apply_visitor(detail::assign_visitor<any>(*this), u);
+    return *this;
+  }
 
-  int size() const { return apply_visitor(detail::size(), *this); }
+  int size() const { return apply_visitor(detail::size_visitor(), *this); }
 
-  int shape() const { return apply_visitor(detail::shape(), *this); }
+  int shape() const { return apply_visitor(detail::shape_visitor(), *this); }
 
-  bool uoflow() const { return apply_visitor(detail::uoflow(), *this); }
+  bool uoflow() const { return apply_visitor(detail::uoflow_visitor(), *this); }
 
   // note: this only works for axes with compatible value type
   int index(const value_type x) const {
-    return apply_visitor(detail::index(x), *this);
+    return apply_visitor(detail::index_visitor(x), *this);
   }
 
   string_view label() const {
-    return apply_visitor(detail::get_label(), *this);
+    return apply_visitor(detail::get_label_visitor(), *this);
   }
 
   void label(const string_view x) {
-    return apply_visitor(detail::set_label(x), *this);
+    return apply_visitor(detail::set_label_visitor(x), *this);
   }
 
   // this only works for axes with compatible bin type
   // and will throw a runtime_error otherwise
   double lower(int idx) const {
-    return apply_visitor(detail::lower(idx), *this);
+    return apply_visitor(detail::lower_visitor(idx), *this);
   }
 
   bin_type operator[](const int idx) const { return bin_type(idx, *this); }
@@ -185,13 +223,14 @@ public:
   }
 
   template <typename... Us>
-  bool operator==(const any<Us...>& rhs) const {
-    return apply_visitor(detail::bicmp(), *this, rhs);
+  bool operator==(const any<Us...>& u) const {
+    return apply_visitor(detail::bicmp_visitor(), *this, u);
   }
 
   template <typename T, typename = requires_bounded_type<T>>
-  bool operator==(const T &) const { // TODO
-    return false;
+  bool operator==(const T & t) const {
+    // variant::operator==(T) is implemented, but only to fail, cannot use it
+    return apply_visitor(detail::cmp_visitor<T>(t), *this);
   }
 
   const_iterator begin() const { return const_iterator(*this, 0); }
@@ -229,24 +268,10 @@ const typename std::add_pointer<T>::type cast(const any<Ts...> *any) {
   return get<T>(&any);
 }
 
-// pass-through versions for generic programming, i.e. when you switch to static
-// histogram
-template <typename T> typename std::add_lvalue_reference<T>::type cast(T &t) {
-  return t;
-}
-
-template <typename T>
-const typename std::add_lvalue_reference<T>::type cast(const T &t) {
-  return t;
-}
-
-template <typename T> typename std::add_pointer<T>::type cast(T *t) {
-  return t;
-}
-
-template <typename T>
-const typename std::add_pointer<T>::type cast(const T *t) {
-  return t;
+// pass-through for generic programming, to keep code workgin when
+// you switch from dynamic to static histogram
+template <typename, typename U> auto cast(U && u) -> decltype(std::forward<U>(u)) {
+  return std::forward<U>(u);
 }
 
 } // namespace axis
diff --git a/include/boost/histogram/detail/meta.hpp b/include/boost/histogram/detail/meta.hpp
index ff496eeb..bea3d143 100644
--- a/include/boost/histogram/detail/meta.hpp
+++ b/include/boost/histogram/detail/meta.hpp
@@ -21,7 +21,7 @@ namespace histogram {
 namespace detail {
 
 #define BOOST_HISTOGRAM_MAKE_SFINAE(name, cond)                  \
-template <typename U> struct name {                              \
+template <typename U> struct name##_impl {                       \
   template <typename T, typename = decltype(cond)>               \
   struct SFINAE {};                                              \
   template <typename T> static std::true_type Test(SFINAE<T> *); \
@@ -29,7 +29,7 @@ template <typename U> struct name {                              \
   using type = decltype(Test<U>(nullptr));                       \
 };                                                               \
 template <typename T>                                            \
-using name##_t = typename name<T>::type
+using name = typename name##_impl<T>::type
 
 BOOST_HISTOGRAM_MAKE_SFINAE(has_variance_support,
                             (std::declval<T&>().value(), std::declval<T&>().variance()));
@@ -51,12 +51,12 @@ struct dynamic_container_tag {};
 struct no_container_tag {};
 
 template <typename T>
-using classify_container_t =
+using classify_container =
   typename std::conditional<
-    is_static_container_t<T>::value,
+    is_static_container<T>::value,
     static_container_tag,
     typename std::conditional<
-      is_dynamic_container_t<T>::value,
+      is_dynamic_container<T>::value,
       dynamic_container_tag,
       no_container_tag
     >::type
@@ -73,10 +73,10 @@ struct requires_iterator {};
 
 template <typename T>
 using requires_axis = decltype(std::declval<T &>().size(),
-                        std::declval<T &>().shape(),
-                        std::declval<T &>().uoflow(),
-                        std::declval<T &>().label(),
-                        std::declval<T &>()[0]);
+                               std::declval<T &>().shape(),
+                               std::declval<T &>().uoflow(),
+                               std::declval<T &>().label(),
+                               std::declval<T &>()[0]);
 
 namespace {
   struct bool_mask_impl {
@@ -93,11 +93,15 @@ std::vector<bool> bool_mask(unsigned n, bool v) {
   return b;
 }
 
-template <typename T>
-using size_of = std::tuple_size<typename std::decay<T>::type>;
+template<class T> using rm_cv_ref = typename std::remove_cv<
+    typename std::remove_reference<T>::type>::type;
 
-template <unsigned D, typename T>
-using type_of = typename std::tuple_element<D, typename std::decay<T>::type>::type;
+template<class T> using mp_size = mp11::mp_size<rm_cv_ref<T>>;
+
+template<typename T, unsigned D> using mp_at_c = mp11::mp_at_c<rm_cv_ref<T>, D>;
+
+template <typename L1, typename L2>
+using mp_union = mp11::mp_rename<mp11::mp_push_front<L2, L1>, mp11::mp_set_push_back>;
 
 namespace {
   template <typename L, typename... Ns>
diff --git a/include/boost/histogram/detail/utility.hpp b/include/boost/histogram/detail/utility.hpp
index 5783f6e4..67993651 100644
--- a/include/boost/histogram/detail/utility.hpp
+++ b/include/boost/histogram/detail/utility.hpp
@@ -98,11 +98,11 @@ private:
 };
 
 template <typename T>
-typename std::enable_if<(is_castable_to_int_t<T>::value), int>::type
+typename std::enable_if<(is_castable_to_int<T>::value), int>::type
 indirect_int_cast(T&&t) noexcept { return static_cast<int>(std::forward<T>(t)); }
 
 template <typename T>
-typename std::enable_if<!(is_castable_to_int_t<T>::value), int>::type
+typename std::enable_if<!(is_castable_to_int<T>::value), int>::type
 indirect_int_cast(T&&) noexcept {
   // Cannot use static_assert here, because this function is created as a
   // side-effect of TMP. It must be valid at compile-time.
diff --git a/include/boost/histogram/dynamic_histogram.hpp b/include/boost/histogram/dynamic_histogram.hpp
index 533c2011..ee33c670 100644
--- a/include/boost/histogram/dynamic_histogram.hpp
+++ b/include/boost/histogram/dynamic_histogram.hpp
@@ -153,7 +153,7 @@ public:
     if (dim() == 1) {
       fill_impl(detail::no_container_tag(), std::forward<T>(t));
     } else {
-      fill_impl(detail::classify_container_t<T>(), std::forward<T>(t));
+      fill_impl(detail::classify_container<T>(), std::forward<T>(t));
     }
   }
 
@@ -175,7 +175,7 @@ public:
     if (dim() == 1) {
       fill_impl(detail::no_container_tag(), std::forward<T>(t), std::move(w));
     } else {
-      fill_impl(detail::classify_container_t<T>(), std::forward<T>(t), std::move(w));
+      fill_impl(detail::classify_container<T>(), std::forward<T>(t), std::move(w));
     }
   }
 
@@ -194,13 +194,13 @@ public:
   template <typename T>
   const_reference at(T&&t) const {
     // check whether T is unpackable
-    return at_impl(detail::classify_container_t<T>(), std::forward<T>(t));
+    return at_impl(detail::classify_container<T>(), std::forward<T>(t));
   }
 
   template <typename T>
   const_reference operator[](T&&t) const {
     // check whether T is unpackable
-    return at_impl(detail::classify_container_t<T>(), std::forward<T>(t));
+    return at_impl(detail::classify_container<T>(), std::forward<T>(t));
   }
 
   /// Number of axes (dimensions) of histogram
@@ -296,10 +296,10 @@ private:
 
   template <typename T, typename... Ts>
   void fill_impl(detail::static_container_tag, T && t, Ts&&... ts) {
-    BOOST_ASSERT_MSG(dim() == detail::size_of<T>::value,
+    BOOST_ASSERT_MSG(dim() == detail::mp_size<T>::value,
                      "fill container does not match histogram dimension");
     std::size_t idx = 0, stride = 1;
-    xlin_get(mp11::mp_int<detail::size_of<T>::value>(), idx, stride, std::forward<T>(t));
+    xlin_get(mp11::mp_int<detail::mp_size<T>::value>(), idx, stride, std::forward<T>(t));
     if (stride) {
       fill_storage_impl(idx, std::forward<Ts>(ts)...);
     }
@@ -329,10 +329,10 @@ private:
 
   template <typename T>
   const_reference at_impl(detail::static_container_tag, T && t) const {
-    BOOST_ASSERT_MSG(dim() == detail::size_of<T>::value,
+    BOOST_ASSERT_MSG(dim() == detail::mp_size<T>::value,
                      "bin container does not match histogram dimension");
     std::size_t idx = 0, stride = 1;
-    lin_get(mp11::mp_int<detail::size_of<T>::value>(), idx, stride, std::forward<T>(t));
+    lin_get(mp11::mp_int<detail::mp_size<T>::value>(), idx, stride, std::forward<T>(t));
     if (stride == 0)
       throw std::out_of_range("bin index out of range");
     return storage_[idx];
@@ -428,8 +428,8 @@ private:
 
   template <int N, typename T> void xlin_get(mp11::mp_int<N>, std::size_t& idx,
     std::size_t & stride, T&&t) const {
-    constexpr unsigned D = detail::size_of<T>::value - N;
-    apply_visitor(xlin_visitor<detail::type_of<D, T>>{idx, stride, std::get<D>(t)}, axes_[D]);
+    constexpr unsigned D = detail::mp_size<T>::value - N;
+    apply_visitor(xlin_visitor<detail::mp_at_c<T, D>>{idx, stride, std::get<D>(t)}, axes_[D]);
     xlin_get(mp11::mp_int<(N-1)>(), idx, stride, std::forward<T>(t));
   }
 
@@ -438,7 +438,7 @@ private:
 
   template <int N, typename T> void lin_get(mp11::mp_int<N>, std::size_t& idx,
     std::size_t & stride, T&&t) const noexcept {
-    constexpr unsigned D = detail::size_of<T>::value - N;
+    constexpr unsigned D = detail::mp_size<T>::value - N;
     apply_visitor(lin_visitor{idx, stride, static_cast<int>(std::get<D>(t))}, axes_[D]);
     lin_get(mp11::mp_int<(N-1)>(), idx, stride, std::forward<T>(t));
   }
@@ -471,45 +471,36 @@ private:
 
 template <typename... Axis>
 dynamic_histogram<
-  mp11::mp_set_push_back<axis::builtins, Axis...>
+  mp11::mp_set_push_back<axis::types, detail::rm_cv_ref<Axis>...>
 >
 make_dynamic_histogram(Axis &&... axis) {
   using H = dynamic_histogram<
-    mp11::mp_set_push_back<axis::builtins, Axis...>
+    mp11::mp_set_push_back<axis::types, detail::rm_cv_ref<Axis>...>
   >;
   return H(std::forward<Axis>(axis)...);
 }
 
-template <typename Storage, typename... Axes>
+template <typename Storage, typename... Axis>
 dynamic_histogram<
-  mp11::mp_set_push_back<axis::builtins, Axes...>,
+  mp11::mp_set_push_back<axis::types, detail::rm_cv_ref<Axis>...>,
   Storage
 >
-make_dynamic_histogram_with(Axes &&... axes) {
+make_dynamic_histogram_with(Axis &&... axis) {
   using H = dynamic_histogram<
-    mp11::mp_set_push_back<axis::builtins, Axes...>,
+    mp11::mp_set_push_back<axis::types, detail::rm_cv_ref<Axis>...>,
     Storage
   >;
-  return H(std::forward<Axes>(axes)...);
+  return H(std::forward<Axis>(axis)...);
 }
 
-template <typename Iterator, typename = detail::requires_iterator<Iterator>>
+template <typename Iterator,
+          typename = detail::requires_iterator<Iterator>>
 dynamic_histogram<
-  mp11::mp_unique<
-    mp11::mp_append<
-      axis::builtins,
-      typename Iterator::value_type::types
-    >
-  >
+  detail::mp_union<axis::types, typename Iterator::value_type::types>
 >
 make_dynamic_histogram(Iterator begin, Iterator end) {
   using H = dynamic_histogram<
-    mp11::mp_unique<
-      mp11::mp_append<
-        axis::builtins,
-        typename Iterator::value_type::types
-      >
-    >
+    detail::mp_union<axis::types, typename Iterator::value_type::types>
   >;
   return H(begin, end);
 }
@@ -517,35 +508,35 @@ make_dynamic_histogram(Iterator begin, Iterator end) {
 // template <typename... Axes>
 // dynamic_histogram<
   
-// detail::union_t<axis::builtins, mp11::mp_list<Axes...>>,
+// detail::union_t<axis::types, mp11::mp_list<Axes...>>,
 //           array_storage<weight_counter<double>>>
 // make_dynamic_weighted_histogram(Axes &&... axes) {
 //   return dynamic_histogram,
-//                    detail::union_t<axis::builtins, mp11::mp_list<Axes...>>,
+//                    detail::union_t<axis::types, mp11::mp_list<Axes...>>,
 //                    array_storage<weight_counter<double>>>(
 //       std::forward<Axes>(axes)...);
 // }
 
 // template <typename Iterator, typename = detail::requires_iterator<Iterator>>
 // dynamic_histogram,
-//           detail::union_t<axis::builtins, typename Iterator::value_type::types>,
+//           detail::union_t<axis::types, typename Iterator::value_type::types>,
 //           array_storage<weight_counter<double>>>
 // make_dynamic_weighted_histogram(Iterator begin, Iterator end) {
 //   return histogram<
 //       dynamic_tag,
-//       detail::union_t<axis::builtins, typename Iterator::value_type::types>,
+//       detail::union_t<axis::types, typename Iterator::value_type::types>,
 //       array_storage<weight_counter<double>>>(begin, end);
 // }
 
 // template <typename Storage, typename Iterator,
 //           typename = detail::requires_iterator<Iterator>>
 // dynamic_histogram,
-//           detail::union_t<axis::builtins, typename Iterator::value_type::types>,
+//           detail::union_t<axis::types, typename Iterator::value_type::types>,
 //           Storage>
 // make_dynamic_histogram_with(Iterator begin, Iterator end) {
 //   return histogram<
 //       dynamic_tag,
-//       detail::union_t<axis::builtins, typename Iterator::value_type::types>,
+//       detail::union_t<axis::types, typename Iterator::value_type::types>,
 //       Storage>(begin, end);
 // }
 
diff --git a/include/boost/histogram/histogram_fwd.hpp b/include/boost/histogram/histogram_fwd.hpp
index 0b79429e..3ce018b1 100644
--- a/include/boost/histogram/histogram_fwd.hpp
+++ b/include/boost/histogram/histogram_fwd.hpp
@@ -33,18 +33,17 @@ template <typename RealType = double> class variable;
 template <typename IntType = int> class integer;
 template <typename T = int> class category;
 
-using builtins =
+using types =
     mp11::mp_list<axis::regular<double, axis::transform::identity>,
-                axis::regular<double, axis::transform::log>,
-                axis::regular<double, axis::transform::sqrt>,
-                axis::regular<double, axis::transform::pow>,
-                axis::circular<double>, axis::variable<double>,
-                axis::integer<int>, axis::category<int>,
-                axis::category<std::string>>;
+                  axis::regular<double, axis::transform::log>,
+                  axis::regular<double, axis::transform::sqrt>,
+                  axis::regular<double, axis::transform::pow>,
+                  axis::circular<double>, axis::variable<double>,
+                  axis::integer<int>, axis::category<int>,
+                  axis::category<std::string>>;
 
 template <typename... Ts> class any;
-
-using any_builtin = mp11::mp_rename<builtins, any>;
+using any_std = mp11::mp_rename<types, any>;
 
 } // namespace axis
 
@@ -53,7 +52,7 @@ struct static_tag {};
 template <class Type, class Axes, class Storage = adaptive_storage>
 class histogram;
 
-template <class Axes = axis::builtins, class Storage = adaptive_storage>
+template <class Axes = axis::types, class Storage = adaptive_storage>
 using dynamic_histogram = histogram<dynamic_tag, Axes, Storage>;
 
 template <class Axes, class Storage = adaptive_storage>
diff --git a/include/boost/histogram/static_histogram.hpp b/include/boost/histogram/static_histogram.hpp
index bb07f040..6dbb04d7 100644
--- a/include/boost/histogram/static_histogram.hpp
+++ b/include/boost/histogram/static_histogram.hpp
@@ -149,7 +149,7 @@ public:
     // check whether we need to unpack argument
     fill_impl(mp11::mp_if_c<(axes_size::value == 1),
                 detail::no_container_tag,
-                detail::classify_container_t<T>>(), std::forward<T>(t));
+                detail::classify_container<T>>(), std::forward<T>(t));
   }
 
   // TODO: merge this with unpacking
@@ -168,7 +168,7 @@ public:
     // check whether we need to unpack argument
     fill_impl(mp11::mp_if_c<(axes_size::value == 1),
                 detail::no_container_tag,
-                detail::classify_container_t<T>>(), std::forward<T>(t), std::move(w));
+                detail::classify_container<T>>(), std::forward<T>(t), std::move(w));
   }
 
   template <typename... Ts>
@@ -186,13 +186,13 @@ public:
   template <typename T>
   const_reference operator[](T&&t) const {
     // check whether we need to unpack argument
-    return at_impl(detail::classify_container_t<T>(), std::forward<T>(t));
+    return at_impl(detail::classify_container<T>(), std::forward<T>(t));
   }
 
   template <typename T>
   const_reference at(T&&t) const {
     // check whether we need to unpack argument
-    return at_impl(detail::classify_container_t<T>(), std::forward<T>(t));
+    return at_impl(detail::classify_container<T>(), std::forward<T>(t));
   }
 
   /// Number of axes (dimensions) of histogram
@@ -296,7 +296,7 @@ private:
 
   template <typename T, typename... Ts>
   void fill_impl(detail::static_container_tag, T&&t, Ts&&...ts) {
-    static_assert(detail::size_of<T>::value == axes_size::value,
+    static_assert(detail::mp_size<T>::value == axes_size::value,
                   "fill container does not match histogram dimension");
     std::size_t idx = 0, stride = 1;
     xlin_get(axes_size(), idx, stride, std::forward<T>(t));
@@ -405,7 +405,7 @@ private:
 
   template <long unsigned int N, typename T>
   void xlin_get(mp11::mp_size_t<N>, std::size_t &idx, std::size_t &stride, T && t) const {
-    constexpr unsigned D = detail::size_of<T>::value - N;
+    constexpr unsigned D = detail::mp_size<T>::value - N;
     const auto a_size = std::get<D>(axes_).size();
     const auto a_shape = std::get<D>(axes_).shape();
     const auto j = std::get<D>(axes_).index(std::get<D>(t));
@@ -418,7 +418,7 @@ private:
 
   template <long unsigned int N, typename T>
   void lin_get(mp11::mp_size_t<N>, std::size_t &idx, std::size_t &stride, T&&t) const noexcept {
-    constexpr unsigned D = detail::size_of<T>::value - N;
+    constexpr unsigned D = detail::mp_size<T>::value - N;
     const auto a_size = std::get<D>(axes_).size();
     const auto a_shape = std::get<D>(axes_).shape();
     const auto j = detail::indirect_int_cast(std::get<D>(t));
diff --git a/test/axis_size.cpp b/test/axis_size.cpp
deleted file mode 100644
index 8941fcba..00000000
--- a/test/axis_size.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright 2015-2017 Hans Dembinski
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt
-// or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#include <boost/histogram/histogram_fwd.hpp>
-#include <boost/histogram/axis/axis.hpp>
-#include <boost/histogram/axis/any.hpp>
-#include <boost/variant.hpp>
-#include <iostream>
-
-namespace boost { namespace histogram {
-    using axis_variant =
-        typename make_variant_over<axis::builtins>::type;
-}}
-
-int main() {
-
-#define SIZEOF(axis)                                                        \
-  std::cout << #axis << " " << sizeof(boost::histogram::axis) << std::endl
-SIZEOF(axis::regular<>);
-SIZEOF(axis::circular<>);
-SIZEOF(axis::variable<>);
-SIZEOF(axis::integer<>);
-SIZEOF(axis::category<>);
-SIZEOF(axis::any<>);
-
-}
diff --git a/test/axis_test.cpp b/test/axis_test.cpp
index 7d0a0bc5..89214660 100644
--- a/test/axis_test.cpp
+++ b/test/axis_test.cpp
@@ -37,7 +37,16 @@ void test_axis_iterator(const Axis &a, int begin, int end) {
 }
 
 int main() {
-  using any_axis = boost::mp11::mp_rename<axis::builtins, axis::any>;
+
+  // sizes
+  {
+    BOOST_TEST_EQ(sizeof(axis::regular<>), 64);
+    BOOST_TEST_EQ(sizeof(axis::circular<>), 56);
+    BOOST_TEST_EQ(sizeof(axis::variable<>), 56);
+    BOOST_TEST_EQ(sizeof(axis::integer<>), 48);
+    BOOST_TEST_EQ(sizeof(axis::category<>), 48);
+    BOOST_TEST_EQ(sizeof(axis::any_std), 80);
+  }
 
   // bad_ctors
   {
@@ -240,40 +249,40 @@ int main() {
     test_axis_iterator(axis::variable<>({1, 2, 3}, ""), 0, 2);
     test_axis_iterator(axis::integer<>(0, 4, ""), 0, 4);
     test_axis_iterator(axis::category<>({A, B, C}, ""), 0, 3);
-    test_axis_iterator(any_axis(axis::regular<>(5, 0, 1)), 0, 5);
-    BOOST_TEST_THROWS(any_axis(axis::category<>({A, B, C})).lower(0),
+    test_axis_iterator(axis::any_std(axis::regular<>(5, 0, 1)), 0, 5);
+    BOOST_TEST_THROWS(axis::any_std(axis::category<>({A, B, C})).lower(0),
                       std::runtime_error);
   }
 
-  // any_axis_type_copyable
+  // any_std_type_copyable
   {
-    any_axis a(axis::regular<>(2, -1, 1));
-    any_axis b(a);
+    axis::any_std a(axis::regular<>(2, -1, 1));
+    axis::any_std b(a);
     BOOST_TEST(a == b);
-    any_axis c;
+    axis::any_std c;
     BOOST_TEST_NOT(a == c);
     c = a;
     BOOST_TEST(a == c);
   }
 
-  // any_axis_type_movable
+  // any_std_type_movable
   {
-    any_axis a(axis::regular<>(2, -1, 1));
-    any_axis r(a);
-    any_axis b(std::move(a));
+    axis::any_std a(axis::regular<>(2, -1, 1));
+    axis::any_std r(a);
+    axis::any_std b(std::move(a));
     BOOST_TEST_EQ(b, r);
-    any_axis c;
+    axis::any_std c;
     BOOST_TEST_NOT(a == c);
     c = std::move(b);
     BOOST_TEST(c == r);
   }
 
-  // any_axis_type_streamable
+  // any_std_type_streamable
   {
     enum { A, B, C };
     std::string a = "A";
     std::string b = "B";
-    std::vector<any_axis> axes;
+    std::vector<axis::any_std> axes;
     axes.push_back(axis::regular<>{2, -1, 1, "regular1"});
     axes.push_back(axis::regular<double, axis::transform::log>(
         2, 1, 10, "regular2", axis::uoflow::off));
@@ -303,27 +312,27 @@ int main() {
     BOOST_TEST_EQ(os.str(), ref);
   }
 
-  // any_axis_type_equal_comparable
+  // any_std_type_equal_comparable
   {
     enum { A, B, C };
-    std::vector<any_axis> axes;
+    std::vector<axis::any_std> axes;
     axes.push_back(axis::regular<>{2, -1, 1});
     axes.push_back(axis::circular<>{4});
     axes.push_back(axis::variable<>{-1, 0, 1});
     axes.push_back(axis::category<>{A, B, C});
     axes.push_back(axis::integer<>{-1, 1});
     for (const auto &a : axes) {
-      BOOST_TEST(!(a == any_axis()));
+      BOOST_TEST(!(a == axis::any_std()));
       BOOST_TEST_EQ(a, a);
     }
-    BOOST_TEST_NOT(axes == std::vector<any_axis>());
-    BOOST_TEST(axes == std::vector<any_axis>(axes));
+    BOOST_TEST_NOT(axes == std::vector<axis::any_std>());
+    BOOST_TEST(axes == std::vector<axis::any_std>(axes));
   }
 
-  // any_axis_type_value_to_index_failure
+  // any_std_type_value_to_index_failure
   {
     std::string a = "A", b = "B";
-    any_axis x = axis::category<std::string>({a, b}, "category");
+    axis::any_std x = axis::category<std::string>({a, b}, "category");
     BOOST_TEST_THROWS(x.index(1.5), std::runtime_error);
     const auto &cx = axis::cast<axis::category<std::string>>(x);
     BOOST_TEST_EQ(cx.index(b), 1);
diff --git a/test/detail_test.cpp b/test/detail_test.cpp
index f145a50a..105ab017 100644
--- a/test/detail_test.cpp
+++ b/test/detail_test.cpp
@@ -149,35 +149,35 @@ int main() {
       const double &variance() const;
     };
 
-    BOOST_TEST_EQ(has_variance_support_t<no_methods>(), false);
-    BOOST_TEST_EQ(has_variance_support_t<value_method>(), false);
-    BOOST_TEST_EQ(has_variance_support_t<variance_method>(),
+    BOOST_TEST_EQ(has_variance_support<no_methods>(), false);
+    BOOST_TEST_EQ(has_variance_support<value_method>(), false);
+    BOOST_TEST_EQ(has_variance_support<variance_method>(),
                   false);
-    BOOST_TEST_EQ(has_variance_support_t<value_and_variance_methods>(),
+    BOOST_TEST_EQ(has_variance_support<value_and_variance_methods>(),
                   true);
   }
 
   // classify_container
   {
-    using result1 = classify_container_t<int>;
+    using result1 = classify_container<int>;
     BOOST_TEST_TRAIT_TRUE(( std::is_same<result1, no_container_tag> ));
 
-    using result1a = classify_container_t<int&>;
+    using result1a = classify_container<int&>;
     BOOST_TEST_TRAIT_TRUE(( std::is_same<result1a, no_container_tag> ));
 
-    using result2 = classify_container_t<std::vector<int>>;
+    using result2 = classify_container<std::vector<int>>;
     BOOST_TEST_TRAIT_TRUE(( std::is_same<result2, dynamic_container_tag> ));
 
-    using result2a = classify_container_t<std::vector<int>&>;
+    using result2a = classify_container<std::vector<int>&>;
     BOOST_TEST_TRAIT_TRUE(( std::is_same<result2a, dynamic_container_tag> ));
 
-    using result3 = classify_container_t<std::pair<int, int>>;
+    using result3 = classify_container<std::pair<int, int>>;
     BOOST_TEST_TRAIT_TRUE(( std::is_same<result3, static_container_tag> ));
 
-    using result3a = classify_container_t<std::pair<int, int>&>;
+    using result3a = classify_container<std::pair<int, int>&>;
     BOOST_TEST_TRAIT_TRUE(( std::is_same<result3a, static_container_tag> ));
 
-    using result4 = classify_container_t<decltype("abc")>;
+    using result4 = classify_container<decltype("abc")>;
     BOOST_TEST_TRAIT_TRUE(( std::is_same<result4, dynamic_container_tag> ));
   }
 
@@ -190,6 +190,31 @@ int main() {
     BOOST_TEST_EQ(v2, std::vector<bool>({false, true, false, true}));
   }
 
+  // rm_cv_ref
+  {
+    using T1 = int;
+    using T2 = const int;
+    using T3 = const int&;
+    using T4 = volatile int;
+    using T5 = volatile const int;
+    using T6 = volatile const int&;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<rm_cv_ref<T1>, int>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<rm_cv_ref<T2>, int>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<rm_cv_ref<T3>, int>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<rm_cv_ref<T4>, int>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<rm_cv_ref<T5>, int>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<rm_cv_ref<T6>, int>));
+  }
+
+  // mp_union
+  {
+    using L1 = mp11::mp_list<int, char, long>;
+    using L2 = mp11::mp_list<char, char*>;
+    using result = mp_union<L1, L2>;
+    using expected = mp11::mp_list<int, char, long, char*>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<result, expected>));
+  }
+
   // literals
   {
     auto j0 = 0_c;
diff --git a/test/histogram_test.cpp b/test/histogram_test.cpp
index f19b163e..16856cde 100644
--- a/test/histogram_test.cpp
+++ b/test/histogram_test.cpp
@@ -44,16 +44,6 @@ auto make_histogram(dynamic_tag, Axes &&... axes)
   return make_dynamic_histogram_with<S>(std::forward<Axes>(axes)...);
 }
 
-template <typename T, typename U>
-bool axis_equal(static_tag, const T &t, const U &u) {
-  return t == u;
-}
-
-template <typename T, typename U>
-bool axis_equal(dynamic_tag, const T &t, const U &u) {
-  return t == u; // need to convert rhs to boost::variant
-}
-
 int expected_moved_from_dim(static_tag, int static_value) {
   return static_value;
 }
@@ -635,7 +625,7 @@ template <typename Type> void run_tests() {
     BOOST_TEST_EQ(h1_0.at(1), 3);
     BOOST_TEST_EQ(h1_0.axis()[0].lower(), 0);
     BOOST_TEST_EQ(h1_0.axis()[1].lower(), 1);
-    BOOST_TEST(axis_equal(Type(), h1_0.axis(), h1.axis(0_c)));
+    BOOST_TEST(h1_0.axis() == h1.axis(0_c));
 
     auto h1_1 = h1.reduce_to(1_c);
     BOOST_TEST_EQ(h1_1.dim(), 1);
@@ -643,7 +633,7 @@ template <typename Type> void run_tests() {
     BOOST_TEST_EQ(h1_1.at(0), 2);
     BOOST_TEST_EQ(h1_1.at(1), 2);
     BOOST_TEST_EQ(h1_1.at(2), 1);
-    BOOST_TEST(axis_equal(Type(), h1_1.axis(), h1.axis(1_c)));
+    BOOST_TEST(h1_1.axis() == h1.axis(1_c));
 
     auto h2 = make_histogram<adaptive_storage>(Type(), axis::integer<>(0, 2),
                                                axis::integer<>(0, 3),
@@ -659,14 +649,14 @@ template <typename Type> void run_tests() {
     BOOST_TEST_EQ(sum(h2_0), 5);
     BOOST_TEST_EQ(h2_0.at(0), 4);
     BOOST_TEST_EQ(h2_0.at(1), 1);
-    BOOST_TEST(axis_equal(Type(), h2_0.axis(), axis::integer<>(0, 2)));
+    BOOST_TEST(h2_0.axis() == axis::integer<>(0, 2));
 
     auto h2_1 = h2.reduce_to(1_c);
     BOOST_TEST_EQ(h2_1.dim(), 1);
     BOOST_TEST_EQ(sum(h2_1), 5);
     BOOST_TEST_EQ(h2_1.at(0), 3);
     BOOST_TEST_EQ(h2_1.at(1), 2);
-    BOOST_TEST(axis_equal(Type(), h2_1.axis(), axis::integer<>(0, 3)));
+    BOOST_TEST(h2_1.axis() == axis::integer<>(0, 3));
 
     auto h2_2 = h2.reduce_to(2_c);
     BOOST_TEST_EQ(h2_2.dim(), 1);
@@ -674,7 +664,7 @@ template <typename Type> void run_tests() {
     BOOST_TEST_EQ(h2_2.at(0), 2);
     BOOST_TEST_EQ(h2_2.at(1), 1);
     BOOST_TEST_EQ(h2_2.at(2), 2);
-    BOOST_TEST(axis_equal(Type(), h2_2.axis(), axis::integer<>(0, 4)));
+    BOOST_TEST(h2_2.axis() == axis::integer<>(0, 4));
 
     auto h2_01 = h2.reduce_to(0_c, 1_c);
     BOOST_TEST_EQ(h2_01.dim(), 2);
@@ -682,8 +672,8 @@ template <typename Type> void run_tests() {
     BOOST_TEST_EQ(h2_01.at(0, 0), 2);
     BOOST_TEST_EQ(h2_01.at(0, 1), 2);
     BOOST_TEST_EQ(h2_01.at(1, 0), 1);
-    BOOST_TEST(axis_equal(Type(), h2_01.axis(0_c), axis::integer<>(0, 2)));
-    BOOST_TEST(axis_equal(Type(), h2_01.axis(1_c), axis::integer<>(0, 3)));
+    BOOST_TEST(h2_01.axis(0_c) == axis::integer<>(0, 2));
+    BOOST_TEST(h2_01.axis(1_c) == axis::integer<>(0, 3));
 
     auto h2_02 = h2.reduce_to(0_c, 2_c);
     BOOST_TEST_EQ(h2_02.dim(), 2);
@@ -692,8 +682,8 @@ template <typename Type> void run_tests() {
     BOOST_TEST_EQ(h2_02.at(0, 1), 1);
     BOOST_TEST_EQ(h2_02.at(0, 2), 1);
     BOOST_TEST_EQ(h2_02.at(1, 2), 1);
-    BOOST_TEST(axis_equal(Type(), h2_02.axis(0_c), axis::integer<>(0, 2)));
-    BOOST_TEST(axis_equal(Type(), h2_02.axis(1_c), axis::integer<>(0, 4)));
+    BOOST_TEST(h2_02.axis(0_c) == axis::integer<>(0, 2));
+    BOOST_TEST(h2_02.axis(1_c) == axis::integer<>(0, 4));
 
     auto h2_12 = h2.reduce_to(1_c, 2_c);
     BOOST_TEST_EQ(h2_12.dim(), 2);
@@ -702,8 +692,8 @@ template <typename Type> void run_tests() {
     BOOST_TEST_EQ(h2_12.at(1, 0), 1);
     BOOST_TEST_EQ(h2_12.at(1, 1), 1);
     BOOST_TEST_EQ(h2_12.at(0, 2), 2);
-    BOOST_TEST(axis_equal(Type(), h2_12.axis(0_c), axis::integer<>(0, 3)));
-    BOOST_TEST(axis_equal(Type(), h2_12.axis(1_c), axis::integer<>(0, 4)));
+    BOOST_TEST(h2_12.axis(0_c) == axis::integer<>(0, 3));
+    BOOST_TEST(h2_12.axis(1_c) == axis::integer<>(0, 4));
   }
 
   // custom axis
@@ -726,7 +716,7 @@ template <typename Type> void run_tests() {
     h("9");
 
     BOOST_TEST_EQ(h.dim(), 1);
-    BOOST_TEST(h.axis() == custom_axis(0, 3));
+    BOOST_TEST_EQ(h.axis(), custom_axis(0, 3));
     BOOST_TEST_EQ(h.at(0), 1);
     BOOST_TEST_EQ(h.at(1), 1);
     BOOST_TEST_EQ(h.at(2), 0);
@@ -980,7 +970,7 @@ int main() {
     BOOST_TEST_EQ(sum(h1_0), 5);
     BOOST_TEST_EQ(h1_0.at(0), 2);
     BOOST_TEST_EQ(h1_0.at(1), 3);
-    BOOST_TEST(axis_equal(dynamic_tag(), h1_0.axis(), h1.axis(0_c)));
+    BOOST_TEST(h1_0.axis() == h1.axis(0_c));
 
     auto h1_1 = h1.reduce_to(1);
     BOOST_TEST_EQ(h1_1.dim(), 1);
@@ -988,7 +978,7 @@ int main() {
     BOOST_TEST_EQ(h1_1.at(0), 2);
     BOOST_TEST_EQ(h1_1.at(1), 2);
     BOOST_TEST_EQ(h1_1.at(2), 1);
-    BOOST_TEST(axis_equal(dynamic_tag(), h1_1.axis(), h1.axis(1_c)));
+    BOOST_TEST(h1_1.axis() == h1.axis(1_c));
   }
 
   // histogram iterator
diff --git a/test/speed_cpp.cpp b/test/speed_cpp.cpp
index dd2b627c..894988f9 100644
--- a/test/speed_cpp.cpp
+++ b/test/speed_cpp.cpp
@@ -137,11 +137,11 @@ int main() {
            compare_1d<static_histogram<mpl::vector<axis::regular<>>,
                                 adaptive_storage>>(nfill, itype));
     printf("hd_ss %.3f\n",
-           compare_1d<dynamic_histogram<axis::builtins,
+           compare_1d<dynamic_histogram<axis::types,
                                 array_storage<int>>>(
                nfill, itype));
     printf("hd_sd %.3f\n",
-           compare_1d<dynamic_histogram<axis::builtins, adaptive_storage>>(
+           compare_1d<dynamic_histogram<axis::types, adaptive_storage>>(
                nfill, itype));
   }
 
@@ -160,11 +160,11 @@ int main() {
                mpl::vector<axis::regular<>, axis::regular<>>,
                adaptive_storage>>(nfill, itype));
     printf("hd_ss %.3f\n",
-           compare_2d<dynamic_histogram<axis::builtins,
+           compare_2d<dynamic_histogram<axis::types,
                       array_storage<int>>>(
                nfill, itype));
     printf("hd_sd %.3f\n",
-           compare_2d<dynamic_histogram<axis::builtins, adaptive_storage>>(
+           compare_2d<dynamic_histogram<axis::types, adaptive_storage>>(
                nfill, itype));
   }
 
@@ -183,11 +183,11 @@ int main() {
                mpl::vector<axis::regular<>, axis::regular<>, axis::regular<>>,
                adaptive_storage>>(nfill, itype));
     printf("hd_ss %.3f\n",
-           compare_3d<dynamic_histogram<axis::builtins,
+           compare_3d<dynamic_histogram<axis::types,
                                 array_storage<int>>>(
                nfill, itype));
     printf("hd_sd %.3f\n",
-           compare_3d<dynamic_histogram<axis::builtins, adaptive_storage>>(
+           compare_3d<dynamic_histogram<axis::types, adaptive_storage>>(
                nfill, itype));
   }
 
@@ -208,11 +208,11 @@ int main() {
                            axis::regular<>, axis::regular<>, axis::regular<>>,
                adaptive_storage>>(nfill, itype));
     printf("hd_ss %.3f\n",
-           compare_6d<dynamic_histogram<axis::builtins,
+           compare_6d<dynamic_histogram<axis::types,
                                 array_storage<int>>>(
                nfill, itype));
     printf("hd_sd %.3f\n",
-           compare_6d<dynamic_histogram<axis::builtins, adaptive_storage>>(
+           compare_6d<dynamic_histogram<axis::types, adaptive_storage>>(
                nfill, itype));
   }
 }