diff --git a/include/boost/histogram/detail/meta.hpp b/include/boost/histogram/detail/meta.hpp
index dd3795d3..4c2c7700 100644
--- a/include/boost/histogram/detail/meta.hpp
+++ b/include/boost/histogram/detail/meta.hpp
@@ -36,7 +36,8 @@ template <typename T, typename = decltype(std::declval<T &>().size(),
 struct requires_storage {};
 
 template <typename T> struct has_variance_support {
-  template <typename U, typename = decltype(std::declval<typename U::bin_type&>().variance())>
+  template <typename U, typename = decltype(std::declval<U&>().value(),
+                                            std::declval<U&>().variance())>
   struct SFINAE {};
   template <typename U> static std::true_type Test(SFINAE<U> *);
   template <typename U> static std::false_type Test(...);
@@ -46,11 +47,6 @@ template <typename T> struct has_variance_support {
 template <typename T>
 using has_variance_support_t = typename has_variance_support<T>::type;
 
-template <typename S, typename ReturnValue = typename S::value_type>
-using requires_variance_support =
-    typename std::enable_if<has_variance_support_t<S>::value,
-                            ReturnValue>::type;
-
 template <typename T,
           typename = decltype(*std::declval<T &>(), ++std::declval<T &>())>
 struct is_iterator {};
@@ -59,15 +55,14 @@ template <typename T, typename = decltype(std::begin(std::declval<T &>()),
                                           std::end(std::declval<T &>()))>
 struct is_sequence {};
 
-template <typename MainVector, typename AuxVector> struct combine {
-  using type =
-      typename mpl::copy_if<AuxVector,
-                            mpl::not_<mpl::contains<MainVector, mpl::_1>>,
-                            mpl::back_inserter<MainVector>>::type;
-};
+template <typename MainVector, typename AuxVector> struct union_ :
+  mpl::copy_if<AuxVector,
+               mpl::not_<mpl::contains<MainVector, mpl::_1>>,
+               mpl::back_inserter<MainVector>>
+{};
 
 template <typename MainVector, typename AuxVector>
-using combine_t = typename combine<MainVector, AuxVector>::type;
+using union_t = typename union_<MainVector, AuxVector>::type;
 
 struct bool_mask_op {
   std::vector<bool> &b;
@@ -97,12 +92,12 @@ void axes_assign_subset(Axes1 &axes1, const Axes &axes) {
 }
 
 template <typename Ns>
-using unique_sorted =
+using unique_sorted_t =
     typename mpl::unique<typename mpl::sort<Ns>::type,
                          std::is_same<mpl::_1, mpl::_2>>::type;
 
 template <typename Axes, typename Numbers>
-using axes_select =
+using axes_select_t =
     typename mpl::transform<Numbers, mpl::at<Axes, mpl::_>>::type;
 
 } // namespace detail
diff --git a/include/boost/histogram/dynamic_histogram.hpp b/include/boost/histogram/dynamic_histogram.hpp
index c7482442..31491380 100644
--- a/include/boost/histogram/dynamic_histogram.hpp
+++ b/include/boost/histogram/dynamic_histogram.hpp
@@ -349,7 +349,7 @@ private:
     }
 
     template <typename Axis> void impl(std::false_type, const Axis &) const {
-      throw std::runtime_error(
+      throw std::invalid_argument(
           detail::cat("fill argument not convertible to axis value type: ",
                       boost::typeindex::type_id<Axis>().pretty_name(), ", ",
                       boost::typeindex::type_id<Value>().pretty_name()));
@@ -417,50 +417,50 @@ private:
 };
 
 template <typename... Axes>
-histogram<dynamic_tag, detail::combine_t<axis::builtins, mpl::vector<Axes...>>>
+histogram<dynamic_tag, detail::union_t<axis::builtins, mpl::vector<Axes...>>>
 make_dynamic_histogram(Axes &&... axes) {
   return histogram<dynamic_tag,
-                   detail::combine_t<axis::builtins, mpl::vector<Axes...>>>(
+                   detail::union_t<axis::builtins, mpl::vector<Axes...>>>(
       std::forward<Axes>(axes)...);
 }
 
 template <typename... Axes>
-histogram<dynamic_tag, detail::combine_t<axis::builtins, mpl::vector<Axes...>>,
+histogram<dynamic_tag, detail::union_t<axis::builtins, mpl::vector<Axes...>>,
 array_storage<weight_counter<double>>>
 make_dynamic_weighted_histogram(Axes &&... axes) {
   return histogram<dynamic_tag,
-                   detail::combine_t<axis::builtins, mpl::vector<Axes...>>,
+                   detail::union_t<axis::builtins, mpl::vector<Axes...>>,
                    array_storage<weight_counter<double>>
     >(std::forward<Axes>(axes)...);
 }
 
 template <typename Storage, typename... Axes>
-histogram<dynamic_tag, detail::combine_t<axis::builtins, mpl::vector<Axes...>>,
+histogram<dynamic_tag, detail::union_t<axis::builtins, mpl::vector<Axes...>>,
           Storage>
 make_dynamic_histogram_with(Axes &&... axes) {
   return histogram<dynamic_tag,
-                   detail::combine_t<axis::builtins, mpl::vector<Axes...>>,
+                   detail::union_t<axis::builtins, mpl::vector<Axes...>>,
                    Storage>(std::forward<Axes>(axes)...);
 }
 
 template <typename Iterator, typename = detail::is_iterator<Iterator>>
-histogram<dynamic_tag, detail::combine_t<axis::builtins,
+histogram<dynamic_tag, detail::union_t<axis::builtins,
                                          typename Iterator::value_type::types>>
 make_dynamic_histogram(Iterator begin, Iterator end) {
   return histogram<
       dynamic_tag,
-      detail::combine_t<axis::builtins, typename Iterator::value_type::types>>(
+      detail::union_t<axis::builtins, typename Iterator::value_type::types>>(
       begin, end);
 }
 
 template <typename Iterator, typename = detail::is_iterator<Iterator>>
-histogram<dynamic_tag, detail::combine_t<axis::builtins,
+histogram<dynamic_tag, detail::union_t<axis::builtins,
                                          typename Iterator::value_type::types>,
                                          array_storage<weight_counter<double>>>
 make_dynamic_weighted_histogram(Iterator begin, Iterator end) {
   return histogram<
       dynamic_tag,
-      detail::combine_t<axis::builtins, typename Iterator::value_type::types>,
+      detail::union_t<axis::builtins, typename Iterator::value_type::types>,
       array_storage<weight_counter<double>>>(
       begin, end);
 }
@@ -469,12 +469,12 @@ template <typename Storage, typename Iterator,
           typename = detail::is_iterator<Iterator>>
 histogram<
     dynamic_tag,
-    detail::combine_t<axis::builtins, typename Iterator::value_type::types>,
+    detail::union_t<axis::builtins, typename Iterator::value_type::types>,
     Storage>
 make_dynamic_histogram_with(Iterator begin, Iterator end) {
   return histogram<
       dynamic_tag,
-      detail::combine_t<axis::builtins, typename Iterator::value_type::types>,
+      detail::union_t<axis::builtins, typename Iterator::value_type::types>,
       Storage>(begin, end);
 }
 
diff --git a/include/boost/histogram/static_histogram.hpp b/include/boost/histogram/static_histogram.hpp
index 642f39d1..010d0894 100644
--- a/include/boost/histogram/static_histogram.hpp
+++ b/include/boost/histogram/static_histogram.hpp
@@ -226,11 +226,11 @@ public:
   /// Returns a lower-dimensional histogram
   template <int N, typename... Rest>
   auto reduce_to(mpl::int_<N>, Rest...) const -> histogram<
-      static_tag, detail::axes_select<Axes, mpl::vector<mpl::int_<N>, Rest...>>,
+      static_tag, detail::axes_select_t<Axes, mpl::vector<mpl::int_<N>, Rest...>>,
       Storage> {
     using HR =
         histogram<static_tag,
-                  detail::axes_select<Axes, mpl::vector<mpl::int_<N>, Rest...>>,
+                  detail::axes_select_t<Axes, mpl::vector<mpl::int_<N>, Rest...>>,
                   Storage>;
     typename HR::axes_type axes;
     detail::axes_assign_subset<mpl::vector<mpl::int_<N>, Rest...>>(axes, axes_);
diff --git a/include/boost/histogram/storage/adaptive_storage.hpp b/include/boost/histogram/storage/adaptive_storage.hpp
index d5cccb67..0627098d 100644
--- a/include/boost/histogram/storage/adaptive_storage.hpp
+++ b/include/boost/histogram/storage/adaptive_storage.hpp
@@ -221,33 +221,18 @@ struct increase_visitor : public static_visitor<void> {
   void operator()(array<wcount> &lhs) const { ++lhs[idx]; }
 };
 
-struct value_visitor : public static_visitor<double> {
+struct bin_visitor : public static_visitor<wcount> {
   const std::size_t idx;
-  value_visitor(const std::size_t i) : idx(i) {}
+  bin_visitor(const std::size_t i) : idx(i) {}
 
-  template <typename Array> double operator()(const Array &b) const {
-    return static_cast<double>(b[idx]);
+  template <typename Array> wcount operator()(const Array &b) const {
+    return wcount(static_cast<double>(b[idx]));
   }
 
-  double operator()(const array<void> & /*b*/) const { return 0; }
+  wcount operator()(const array<void> & /*b*/) const { return wcount(0.0); }
 
-  double operator()(const array<wcount> &b) const {
-    return b[idx].value();
-  }
-};
-
-struct variance_visitor : public static_visitor<double> {
-  const std::size_t idx;
-  variance_visitor(const std::size_t i) : idx(i) {}
-
-  template <typename Array> double operator()(const Array &b) const {
-    return static_cast<double>(b[idx]);
-  }
-
-  double operator()(const array<void> & /*b*/) const { return 0; }
-
-  double operator()(const array<wcount> &b) const {
-    return b[idx].variance();
+  wcount operator()(const array<wcount> &b) const {
+    return b[idx];
   }
 };
 
@@ -422,23 +407,22 @@ public:
   explicit adaptive_storage(const RHS &rhs)
       : buffer_(detail::array<void>(rhs.size())) {
     using T = typename RHS::bin_type;
-    for (auto i = 0ul, n = rhs.size(); i < n; ++i) {
+    for (std::size_t i = 0, n = rhs.size(); i < n; ++i) {
       apply_visitor(detail::assign_visitor<T>(buffer_, i, rhs[i]),
                     buffer_);
     }
   }
 
   template <typename RHS> adaptive_storage &operator=(const RHS &rhs) {
+    // no check for self-assign needed, default operator above is better match
+    const auto n = rhs.size();
+    if (size() != n) {
+      buffer_ = detail::array<void>(n);
+    }
     using T = typename RHS::bin_type;
-    if (static_cast<const void *>(this) != static_cast<const void *>(&rhs)) {
-      const auto n = rhs.size();
-      if (size() != n) {
-        buffer_ = detail::array<void>(n);
-      }
-      for (auto i = 0ul; i < n; ++i) {
-        apply_visitor(detail::assign_visitor<T>(buffer_, i, rhs[i]),
-                      buffer_);
-      }
+    for (std::size_t i = 0; i < n; ++i) {
+      apply_visitor(detail::assign_visitor<T>(buffer_, i, rhs[i]),
+                    buffer_);
     }
     return *this;
   }
@@ -451,6 +435,14 @@ public:
     apply_visitor(detail::increase_visitor(buffer_, i), buffer_);
   }
 
+  void add(std::size_t i, const bin_type& x) {
+    if (x.has_trivial_variance()) {
+      apply_visitor(detail::radd_visitor<double>(buffer_, i, x.value()), buffer_);
+    } else {
+      apply_visitor(detail::radd_visitor<bin_type>(buffer_, i, x), buffer_);
+    }
+  }
+
   template <typename T> void add(std::size_t i, const T &t) {
     apply_visitor(detail::radd_visitor<T>(buffer_, i, t), buffer_);
   }
@@ -460,18 +452,8 @@ public:
                   buffer_);
   }
 
-  void add(std::size_t i, const bin_type& x) {
-    if (x.value() == x.variance()) {
-      apply_visitor(detail::radd_visitor<double>(buffer_, i, x.value()), buffer_);
-    } else {
-      apply_visitor(detail::radd_visitor<bin_type>(buffer_, i, x), buffer_);
-    }
-  }
-
   bin_type operator[](std::size_t i) const {
-    // TODO optimize this with a dedicated visitor
-    return {apply_visitor(detail::value_visitor(i), buffer_),
-            apply_visitor(detail::variance_visitor(i), buffer_)};
+    return apply_visitor(detail::bin_visitor(i), buffer_);
   }
 
   bool operator==(const adaptive_storage &rhs) const {
diff --git a/include/boost/histogram/storage/array_storage.hpp b/include/boost/histogram/storage/array_storage.hpp
index 43460a0f..b050911b 100644
--- a/include/boost/histogram/storage/array_storage.hpp
+++ b/include/boost/histogram/storage/array_storage.hpp
@@ -8,10 +8,9 @@
 #define _BOOST_HISTOGRAM_STORAGE_ARRAY_HPP_
 
 #include <algorithm>
-#include <boost/histogram/detail/meta.hpp>
+#include <boost/histogram/storage/weight_counter.hpp>
 #include <cstddef>
 #include <memory>
-#include <type_traits>
 
 // forward declaration for serialization
 namespace boost {
@@ -55,16 +54,14 @@ public:
 
   template <typename S> explicit array_storage(const S &other) {
     reset(other.size());
-    for (decltype(size_) i = 0u; i < size_; ++i) {
+    for (std::size_t i = 0; i < size_; ++i)
       array_[i] = static_cast<bin_type>(other[i]);
-    }
   }
 
   template <typename S> array_storage &operator=(const S &other) {
     reset(other.size());
-    for (decltype(size_) i = 0u; i < size_; ++i) {
+    for (std::size_t i = 0; i < size_; ++i)
       array_[i] = static_cast<bin_type>(other[i]);
-    }
     return *this;
   }
 
diff --git a/include/boost/histogram/storage/weight_counter.hpp b/include/boost/histogram/storage/weight_counter.hpp
index b24dda53..49aa68ce 100644
--- a/include/boost/histogram/storage/weight_counter.hpp
+++ b/include/boost/histogram/storage/weight_counter.hpp
@@ -8,6 +8,7 @@
 #define _BOOST_HISTOGRAM_STORAGE_WEIGHT_COUNTER_HPP_
 
 #include <boost/histogram/histogram_fwd.hpp>
+#include <stdexcept>
 
 namespace boost {
 
@@ -27,17 +28,7 @@ public:
   weight_counter &operator=(const weight_counter &) = default;
   weight_counter &operator=(weight_counter &&) = default;
 
-  weight_counter(RealType value, RealType variance) : w(value), w2(variance) {}
-
-  template <typename T>
-  explicit weight_counter(const T &t)
-      : w(static_cast<RealType>(t)), w2(static_cast<RealType>(t)) {}
-
-  template <typename T> weight_counter &operator=(const T &t) {
-    w = static_cast<RealType>(t);
-    w2 = static_cast<RealType>(t);
-    return *this;
-  }
+  weight_counter(const RealType& value, const RealType& variance) : w(value), w2(variance) {}
 
   weight_counter &operator++() {
     ++w;
@@ -45,27 +36,28 @@ public:
     return *this;
   }
 
-  template <typename U>
-  weight_counter &operator+=(const weight_counter<U> &rhs) {
-    w += rhs.w;
-    w2 += rhs.w2;
-    return *this;
-  }
-
-  template <typename U>
-  weight_counter &operator+=(const detail::weight_t<U> &rhs) {
-    w += rhs.value;
-    w2 += rhs.value * rhs.value;
-    return *this;
-  }
-
   weight_counter &operator+=(const RealType &x) {
     w += x;
     w2 += x;
     return *this;
   }
 
-  weight_counter &operator*=(const RealType x) {
+  template <typename T>
+  weight_counter &operator+=(const weight_counter<T> &rhs) {
+    w += static_cast<RealType>(rhs.w);
+    w2 += static_cast<RealType>(rhs.w2);
+    return *this;
+  }
+
+  template <typename T>
+  weight_counter &operator+=(const detail::weight_t<T> &rhs) {
+    const auto x = static_cast<RealType>(rhs.value);
+    w += x;
+    w2 += x * x;
+    return *this;
+  }
+
+  weight_counter &operator*=(const RealType &x) {
     w *= x;
     w2 *= x * x;
     return *this;
@@ -77,11 +69,11 @@ public:
 
   bool operator!=(const weight_counter &rhs) const { return !operator==(rhs); }
 
-  template <typename U> bool operator==(const weight_counter<U> &rhs) const {
+  template <typename T> bool operator==(const weight_counter<T> &rhs) const {
     return w == rhs.w && w2 == rhs.w2;
   }
 
-  template <typename U> bool operator!=(const weight_counter<U> &rhs) const {
+  template <typename T> bool operator!=(const weight_counter<T> &rhs) const {
     return !operator==(rhs);
   }
 
@@ -93,9 +85,27 @@ public:
     return !operator==(rhs);
   }
 
-  RealType value() const noexcept { return w; }
-  RealType variance() const noexcept { return w2; }
-  template <typename T> explicit operator T() const noexcept { return w; }
+  const RealType& value() const noexcept { return w; }
+  const RealType& variance() const noexcept { return w2; }
+
+  bool has_trivial_variance() const noexcept { return w == w2; }
+
+  // conversion
+  template <typename T> explicit weight_counter(const T &t) : w(static_cast<T>(t)), w2(w) {}
+  explicit operator RealType() const {
+    if (!has_trivial_variance())
+      throw std::logic_error("cannot convert weight_counter to RealType, value and variance differ");
+    return w;
+  }
+  template <typename T> explicit operator T() const {
+    if (!has_trivial_variance())
+      throw std::logic_error("cannot convert weight_counter to RealType, value and variance differ");
+    return w;
+  }
+  template <typename T> weight_counter &operator=(const T &x) {
+    w = w2 = static_cast<RealType>(x);
+    return *this;
+  }
 
 private:
   friend class ::boost::serialization::access;
diff --git a/src/python/histogram.cpp b/src/python/histogram.cpp
index 65ed16e7..604c6fd8 100644
--- a/src/python/histogram.cpp
+++ b/src/python/histogram.cpp
@@ -334,14 +334,21 @@ std::string histogram_repr(const pyhistogram &h) {
   return os.str();
 }
 
+double bin_type_value(const pyhistogram::bin_type& b) {
+  return b.value();
+}
+
+double bin_type_variance(const pyhistogram::bin_type& b) {
+  return b.variance();
+}
+
 void register_histogram() {
   bp::docstring_options dopt(true, true, false);
 
   bp::class_<pyhistogram::bin_type>(
       "bin_type", "Holds value and variance of bin count.", bp::no_init)
-      .add_property("value", &pyhistogram::bin_type::value)
-      .add_property("variance", &pyhistogram::bin_type::variance)
-      ;
+      .add_property("value", bin_type_value)
+      .add_property("variance", bin_type_variance);
 
   bp::class_<pyhistogram, boost::shared_ptr<pyhistogram>>(
       "histogram", "N-dimensional histogram for real-valued data.", bp::no_init)
diff --git a/test/meta_test.cpp b/test/meta_test.cpp
index b6cb9cca..e8e02377 100644
--- a/test/meta_test.cpp
+++ b/test/meta_test.cpp
@@ -2,6 +2,7 @@
 #include <boost/histogram/detail/meta.hpp>
 #include <boost/mpl/equal.hpp>
 #include <boost/mpl/vector_c.hpp>
+#include <boost/mpl/vector.hpp>
 #include <type_traits>
 
 using namespace boost;
@@ -9,25 +10,50 @@ using namespace boost::mpl;
 using namespace boost::histogram::detail;
 
 int main() {
+  // unique_sorted
   {
     typedef vector_c<int, 2, 1, 1, 3> numbers;
     typedef vector_c<int, 1, 2, 3> expected;
-    using result = unique_sorted<numbers>;
+    using result = unique_sorted_t<numbers>;
 
     BOOST_MPL_ASSERT((equal<result, expected, equal_to<_, _>>));
   }
 
-  struct no_variance_method {
-    using bin_type = int;
-  };
+  // union
+  {
+    typedef vector<int, unsigned, char> main_vector;
+    typedef vector<unsigned, void*> aux_vector;
+    using result = union_t<main_vector, aux_vector>;
 
-  struct variance_method {
-    struct bin_type { double variance() const; };
-  };
+    typedef vector<int, unsigned, char, void*> expected;
+    BOOST_MPL_ASSERT((equal<result, expected, std::is_same<_, _>>));
+  }
 
-  BOOST_TEST_EQ(typename has_variance_support<no_variance_method>::type(),
-                false);
-  BOOST_TEST_EQ(typename has_variance_support<variance_method>::type(), true);
+  // has_variance_support
+  {
+    struct no_methods {};
+
+    struct value_method {
+      const double& value() const;
+    };
+
+    struct variance_method {
+      const double& variance() const;
+    };
+
+    struct value_and_variance_methods {
+      const double& value() const;
+      const double& variance() const;
+    };
+
+    BOOST_TEST_EQ(typename has_variance_support<no_methods>::type(),
+                  false);
+    BOOST_TEST_EQ(typename has_variance_support<value_method>::type(),
+                  false);
+    BOOST_TEST_EQ(typename has_variance_support<variance_method>::type(),
+                  false);
+    BOOST_TEST_EQ(typename has_variance_support<value_and_variance_methods>::type(), true);
+  }
 
   return boost::report_errors();
 }
\ No newline at end of file