diff --git a/examples/getting_started_listing_02.cpp b/examples/getting_started_listing_02.cpp
index bfb32e47..ea9e9783 100644
--- a/examples/getting_started_listing_02.cpp
+++ b/examples/getting_started_listing_02.cpp
@@ -10,42 +10,42 @@ namespace br = boost::random;
 namespace bh = boost::histogram;
 
 int main() {
-    /*
-        create a dynamic histogram with the factory `make_dynamic_histogram`
-        - axis can be passed directly just like for `make_static_histogram`
-        - 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_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"));
-    auto h = bh::make_dynamic_histogram(axes.begin(), axes.end());
+  /*
+      create a dynamic histogram with the factory `make_dynamic_histogram`
+      - axis can be passed directly just like for `make_static_histogram`
+      - 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_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"));
+  auto h = bh::make_dynamic_histogram(axes.begin(), axes.end());
 
-    // fill histogram with random numbers
-    br::mt19937 gen;
-    br::normal_distribution<> norm;
-    for (int i = 0; i < 1000; ++i)
-        h(i % 2 ? "red" : "blue", norm(gen), norm(gen));
+  // fill histogram with random numbers
+  br::mt19937 gen;
+  br::normal_distribution<> norm;
+  for (int i = 0; i < 1000; ++i)
+    h(i % 2 ? "red" : "blue", norm(gen), norm(gen));
 
-    /*
-        print dynamic histogram by iterating over bins
-        - for most axis types, the for loop looks just like for a static
-          histogram, except that we can pass runtime numbers, too
-        - if the [bin type] of the axis is not convertible to a
-          double interval, one needs to cast axis::any before looping;
-          this is here the case for the category axis
-    */
-    using cas = bh::axis::category<std::string>;
-    for (auto cbin : bh::axis::cast<cas>(h.axis(0))) {
-        std::printf("%s\n", cbin.value().c_str());
-        for (auto ybin : h.axis(2)) { // rows
-            for (auto xbin : h.axis(1)) { // columns
-                std::printf("%3.0f ", h.at(cbin, xbin, ybin).value());
-            }
-            std::printf("\n");
-        }
+  /*
+      print dynamic histogram by iterating over bins
+      - for most axis types, the for loop looks just like for a static
+        histogram, except that we can pass runtime numbers, too
+      - if the [bin type] of the axis is not convertible to a
+        double interval, one needs to cast axis::any before looping;
+        this is here the case for the category axis
+  */
+  using cas = bh::axis::category<std::string>;
+  for (auto cbin : static_cast<const cas&>(h.axis(0))) {
+    std::printf("%s\n", cbin.value().c_str());
+    for (auto ybin : h.axis(2)) {   // rows
+      for (auto xbin : h.axis(1)) { // columns
+        std::printf("%3.0f ", h.at(cbin, xbin, ybin).value());
+      }
+      std::printf("\n");
     }
+  }
 }
 
 //]
diff --git a/include/boost/histogram/axis/any.hpp b/include/boost/histogram/axis/any.hpp
index 643a6e24..936579db 100644
--- a/include/boost/histogram/axis/any.hpp
+++ b/include/boost/histogram/axis/any.hpp
@@ -15,9 +15,7 @@
 #include <boost/histogram/histogram_fwd.hpp>
 #include <boost/mp11.hpp>
 #include <boost/utility/string_view.hpp>
-#include <boost/variant/apply_visitor.hpp>
-#include <boost/variant/get.hpp>
-#include <boost/variant/variant.hpp>
+#include <boost/variant.hpp>
 #include <stdexcept>
 #include <type_traits>
 #include <utility>
@@ -32,16 +30,16 @@ class access;
 namespace boost {
 namespace histogram {
 namespace axis {
+
 namespace detail {
 
-// this is evil
-struct offset_visitor : public boost::static_visitor<int> {
-  const char* ptr;
-  template <typename T>
-  offset_visitor(const T* t) : ptr(reinterpret_cast<const char*>(t)) {}
-  template <typename Axis>
-  int operator()(const Axis& a) const {
-    return reinterpret_cast<const char*>(&a) - ptr;
+// this visitation may be collapsed by the compiler almost into a direct cast,
+// works with gcc-8 -O2 -DNDEBUG on Compiler Explorer at least
+template <typename T>
+struct static_cast_visitor : public boost::static_visitor<T> {
+  template <typename A>
+  T operator()(A&& a) const {
+    return static_cast<T>(std::forward<A>(a));
   }
 };
 
@@ -54,7 +52,7 @@ struct index_visitor : public boost::static_visitor<int> {
   }
   template <typename Axis>
   int impl(std::true_type, const Axis& a) const {
-    return a.index(static_cast<typename Axis::value_type>(x));
+    return a.index(x);
   }
   template <typename Axis>
   int impl(std::false_type, const Axis&) const {
@@ -75,7 +73,7 @@ struct lower_visitor : public boost::static_visitor<double> {
             bool,
             (std::is_convertible<typename Axis::value_type, double>::value &&
              std::is_same<typename Axis::bin_type,
-                          axis::interval_view<Axis>>::value)>(),
+                          interval_view<Axis>>::value)>(),
         a);
   }
   template <typename Axis>
@@ -87,7 +85,7 @@ struct lower_visitor : public boost::static_visitor<double> {
     throw std::runtime_error(boost::histogram::detail::cat(
         "cannot use ", boost::typeindex::type_id<Axis>().pretty_name(),
         " with generic boost::histogram::axis::any interface, use"
-        " boost::histogram::axis::cast to access underlying axis type"));
+        " a static_cast to access the underlying axis type"));
   }
 };
 
@@ -131,42 +129,21 @@ struct assign_visitor : public boost::static_visitor<void> {
 /// Polymorphic axis type
 template <typename... Ts>
 class any : public boost::variant<Ts...> {
-  static_assert(boost::histogram::detail::is_common_base<base, Ts...>::value,
-                "all bounded types of axis::any must derive from axis::base");
+  using base_type = boost::variant<Ts...>;
 
- public:
+public:
   using types = mp11::mp_list<Ts...>;
   using value_type = double;
   using bin_type = interval_view<any>;
   using const_iterator = iterator_over<any>;
   using const_reverse_iterator = reverse_iterator_over<any>;
 
- private:
-  using base_type = boost::variant<Ts...>;
-
+private:
   template <typename T>
   using requires_bounded_type = mp11::mp_if<
-      mp11::mp_contains<types, boost::histogram::detail::rm_cv_ref<T>>,
-      void>;
+      mp11::mp_contains<types, boost::histogram::detail::rm_cv_ref<T>>, void>;
 
-  const base& cast_to_base() const {
-    // evil implementation until proper support can be added to boost::variant
-    if (offset_ == -1) {
-      offset_ = boost::apply_visitor(detail::offset_visitor(this), *this);
-    }
-    return *reinterpret_cast<const base*>(reinterpret_cast<const char*>(this) +
-                                          offset_);
-  }
-
-  base& cast_to_base() {
-    // evil implementation until proper support can be added to boost::variant
-    if (offset_ == -1) {
-      offset_ = boost::apply_visitor(detail::offset_visitor(this), *this);
-    }
-    return *reinterpret_cast<base*>(reinterpret_cast<char*>(this) + offset_);
-  }
-
- public:
+public:
   any() = default;
   any(const any&) = default;
   any& operator=(const any&) = default;
@@ -193,21 +170,23 @@ class any : public boost::variant<Ts...> {
     return *this;
   }
 
-  int size() const { return cast_to_base().size(); }
+  int size() const { return static_cast<const base&>(*this).size(); }
 
-  int shape() const { return cast_to_base().shape(); }
+  int shape() const { return static_cast<const base&>(*this).shape(); }
 
-  bool uoflow() const { return cast_to_base().uoflow(); }
-
-  string_view label() const { return cast_to_base().label(); }
-
-  void label(const string_view x) { cast_to_base().label(x); }
+  bool uoflow() const { return static_cast<const base&>(*this).uoflow(); }
 
   // note: this only works for axes with compatible value type
   int index(const value_type x) const {
     return boost::apply_visitor(detail::index_visitor(x), *this);
   }
 
+  string_view label() const {
+    return static_cast<const base&>(*this).label();
+  }
+
+  void label(const string_view x) { static_cast<base&>(*this).label(x); }
+
   // this only works for axes with compatible bin type
   // and will throw a runtime_error otherwise
   double lower(int idx) const {
@@ -227,14 +206,33 @@ class any : public boost::variant<Ts...> {
 
   template <typename T, typename = requires_bounded_type<T>>
   bool operator==(const T& t) const {
-    // variant::operator==(T) is implemented, but only to fail, cannot use it
-    auto tp = boost::get<boost::histogram::detail::rm_cv_ref<T>>(this);
+    // variant::operator==(T) is implemented only to fail, we cannot use it
+    auto tp = boost::get<T>(this);
     return tp && *tp == t;
   }
 
   template <typename T>
-  bool operator!=(T&& t) const {
-    return !operator==(std::forward<T>(t));
+  bool operator!=(const T& t) const {
+    return !operator==(t);
+  }
+
+  explicit operator const base&() const {
+    return boost::apply_visitor(detail::static_cast_visitor<const base&>(),
+                                *this);
+  }
+
+  explicit operator base&() {
+    return boost::apply_visitor(detail::static_cast_visitor<base&>(), *this);
+  }
+
+  template <typename T>
+  explicit operator const T&() const {
+    return boost::strict_get<T>(*this);
+  }
+
+  template <typename T>
+  explicit operator T&() {
+    return boost::strict_get<T>(*this);
   }
 
   const_iterator begin() const { return const_iterator(*this, 0); }
@@ -246,46 +244,12 @@ class any : public boost::variant<Ts...> {
     return const_reverse_iterator(*this, 0);
   }
 
- private:
-  mutable int offset_ = -1;
+private:
   friend class boost::serialization::access;
   template <typename Archive>
   void serialize(Archive&, unsigned);
 };
 
-// dynamic casts
-template <typename T, typename... Ts>
-T&& cast(any<Ts...>&& x) {
-  return boost::strict_get<T>(x);
-}
-
-template <typename T, typename... Ts>
-T& cast(any<Ts...>& x) {
-  return boost::strict_get<T>(x);
-}
-
-template <typename T, typename... Ts>
-const T& cast(const any<Ts...>& x) {
-  return boost::strict_get<T>(x);
-}
-
-template <typename T, typename... Ts>
-T* cast(any<Ts...>* x) {
-  return boost::strict_get<T>(&x);
-}
-
-template <typename T, typename... Ts>
-const T* cast(const any<Ts...>* x) {
-  return boost::strict_get<T>(&x);
-}
-
-// 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
 } // namespace histogram
 } // namespace boost
diff --git a/include/boost/histogram/detail/meta.hpp b/include/boost/histogram/detail/meta.hpp
index 696ca2f9..a9b9b2fd 100644
--- a/include/boost/histogram/detail/meta.hpp
+++ b/include/boost/histogram/detail/meta.hpp
@@ -117,11 +117,6 @@ using copy_qualifiers = mp11::mp_if<
                     T2&>,
         mp11::mp_if<std::is_const<T1>, const T2, T2>>>;
 
-template <typename T, typename... Ts>
-using is_common_base =
-    mp11::mp_all<mp11::mp_all_of_q<mp11::mp_list<Ts...>,
-                                   mp11::mp_bind_front<std::is_base_of, T>>>;
-
 template <typename S, typename L>
 using mp_set_union =
     mp11::mp_apply_q<mp11::mp_bind_front<mp11::mp_set_push_back, S>, L>;
diff --git a/test/axis_test.cpp b/test/axis_test.cpp
index bf9f18ad..4c534005 100644
--- a/test/axis_test.cpp
+++ b/test/axis_test.cpp
@@ -331,7 +331,7 @@ int main() {
     std::string a = "A", b = "B";
     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);
+    auto cx = static_cast<const axis::category<std::string>&>(x);
     BOOST_TEST_EQ(cx.index(b), 1);
   }
 
diff --git a/test/histogram_test.cpp b/test/histogram_test.cpp
index 1ded757a..0cce79fa 100644
--- a/test/histogram_test.cpp
+++ b/test/histogram_test.cpp
@@ -48,9 +48,7 @@ int expected_moved_from_dim(static_tag, int static_value) {
   return static_value;
 }
 
-int expected_moved_from_dim(dynamic_tag, int) {
-  return 0;
-}
+int expected_moved_from_dim(dynamic_tag, int) { return 0; }
 
 template <typename Histogram>
 typename Histogram::element_type sum(const Histogram& h) {
@@ -212,8 +210,8 @@ void run_tests() {
     BOOST_TEST_EQ(c.axis().index(B), 1);
     c.axis().label("foo");
     BOOST_TEST_EQ(c.axis().label(), "foo");
-    // need to cast here for this to work with Type == dynamic_tag
-    auto ca = axis::cast<axis::category<>>(c.axis());
+    // need to cast here for this to work with Type == dynamic_tag, too
+    auto ca = static_cast<const axis::category<>&>(c.axis());
     BOOST_TEST_EQ(ca[0].value(), A);
   }
 
@@ -827,8 +825,7 @@ void run_tests() {
   // STL compatibility
   {
     auto h = make_histogram<adaptive_storage>(Type(), axis::integer<>(0, 3));
-    for (int i = 0; i < 3; ++i)
-      h(i);
+    for (int i = 0; i < 3; ++i) h(i);
     auto a = std::vector<weight_counter<double>>();
     std::partial_sum(h.begin(), h.end(), std::back_inserter(a));
     BOOST_TEST_EQ(a[0].value(), 1);