diff --git a/doc/benchmarks.qbk b/doc/benchmarks.qbk
index e8bb4e52..d9cfef40 100644
--- a/doc/benchmarks.qbk
+++ b/doc/benchmarks.qbk
@@ -9,11 +9,11 @@ The following plot shows results of a benchmark on a 9 GHz Macbook Pro. Random n
 [variablelist Plot legend:
 	[[root] [[@https://root.cern.ch ROOT classes] (`TH1I` for 1D, `TH3I` for 3D and `THnI` for 6D)]]
 	[[py:numpy] [numpy functions ([python]`numpy.histogram` for 1D, `numpy.histogramdd` for 2D, 3D, and 6D)]]
-	[[py:hd_sd] [[classref boost::histogram::histogram<Dynamic,...>] with [classref boost::histogram::adaptive_storage<>], called from Python]]
+	[[py:hd_sd] [[classref boost::histogram::histogram<Dynamic,...>] with [classref boost::histogram::adaptive_storage], called from Python]]
 	[[hs_ss] [[classref boost::histogram::histogram<Static,...>] with [classref boost::histogram::array_storage<int>]]]
-	[[hs_sd] [[classref boost::histogram::histogram<Static,...>] with [classref boost::histogram::adaptive_storage<>]]]
+	[[hs_sd] [[classref boost::histogram::histogram<Static,...>] with [classref boost::histogram::adaptive_storage]]]
 	[[hd_ss] [[classref boost::histogram::histogram<Dynamic,...>] with [classref boost::histogram::array_storage<int>]]]
-	[[hd_sd] [[classref boost::histogram::histogram<Dynamic,...>] with [classref boost::histogram::adaptive_storage<>]]]
+	[[hd_sd] [[classref boost::histogram::histogram<Dynamic,...>] with [classref boost::histogram::adaptive_storage]]]
 ]
 
 [classref boost::histogram::histogram<Static,...>] is always faster than [classref boost::histogram::histogram<Dynamic,...>] and safer to use, as more checks are done at compile time. It is recommended when working in C++ only. [classref boost::histogram::adaptive_storage] is faster than [classref boost::histogram::array_storage] for histograms with many bins, because it uses the cache more effectively due to its smaller memory consumption per bin. If the number of bins is small, it is slower because of overhead of handling memory in a dynamic way.
diff --git a/doc/guide.qbk b/doc/guide.qbk
index 8028826a..d1950b91 100644
--- a/doc/guide.qbk
+++ b/doc/guide.qbk
@@ -59,13 +59,14 @@ By default, under- and overflow bins are added automatically for each axis range
 namespace bh = boost::histogram;
 
 int main() {
-	// create a 1d-histogram for dice throws, eyes are always between 1 and 6
-	auto h = bh::make_static_histogram(bh::axis::integer<>(1, 6, "eyes", bh::axis::without_uoflow));
+	// create a 1d-histogram for dice throws with eye values from 1 to 6
+	auto h = bh::make_static_histogram(bh::axis::integer<>(1, 7, "eyes", bh::axis::uoflow::off));
 	// do something with h
 }
 ``
 
-Using a [classref boost::histogram::axis::integer integer axis] in this example is convenient, because the input values are integers and we want one bin for each eye value.
+Using a [classref boost::histogram::axis::integer integer axis] in this example is convenient, because the input values are integers and we want one bin for each eye value. The intervals in all axes are always semi-open, the last value is never included. That's why the upper end is 7 and not 6, here. This is similar to iterator
+ranges from `begin` to `end`, where `end` is also not included.
 [note The specialised [classref boost::histogram::axis::circular circular axis] never creates under- and overflow bins, because the axis is circular. The highest bin wrapps around to the lowest bin and vice versa, so there is no need for extra bins.]
 
 When you work with [classref boost::histogram::histogram<Dynamic,...>], you can also create a histogram from a run-time compiled collection of axis objects:
@@ -81,13 +82,13 @@ int main() {
 	using hist_type = bh::histogram<bh::Dynamic, bh::builtin_axes>;
 	auto v = std::vector<hist_type::axis_type>();
 	v.push_back(bh::axis::regular<>(100, -1, 1));
-	v.push_back(bh::axis::integer(1, 6));
+	v.push_back(bh::axis::integer<>(1, 6));
 	auto h = hist_type(v.begin(), v.end());
 	// do something with h
 }
 ``
 
-[note In all these examples, memory for bin counters is allocated lazily, because the default policy [classref boost::histogram::adaptive_storage<>] is used. Allocation is deferred to the first call to `fill(...)`, which are described in the next section. Therefore memory allocation exceptions are not thrown when the histogram is created, but possibly later on the first fill.]
+[note In all these examples, memory for bin counters is allocated lazily, because the default policy [classref boost::histogram::adaptive_storage] is used. Allocation is deferred to the first call to `fill(...)`, which are described in the next section. Therefore memory allocation exceptions are not thrown when the histogram is created, but possibly later on the first fill.]
 
 [endsect]
 
@@ -138,7 +139,7 @@ Here is a second example which using a weighted fill in a functional programming
 namespace bh = boost::histogram;
 
 int main() {
-	auto h = bh::make_static_histogram(bh::axis::integer(0, 9));
+	auto h = bh::make_static_histogram(bh::axis::integer<>(0, 9));
 	std::vector<int> v{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
 	std::for_each(v.begin(), v.end(), [&h](int x) { h.fill(x, bh::weight(2.0)); });
 	// h is now filled
@@ -188,7 +189,7 @@ cpp_filler.process(h) # histogram is filled with input values
 
 In Python, you can straight-forwardly create a histogram object with a variable number of axis arguments. The histogram instance passes the language barrier without copying its internal (possibly large) data buffer, so this workflow is efficient.
 
-You can also fill the histogram in Python. If you pass the input values as numpy arrays, this is quite efficient and almost as fast as using C++, see the [link histogram.benchmarks benchmark]. Looping over a collection in Python, however, is very slow and should be avoided. Here is an example to illustrate:
+You can also fill the histogram in Python. Looping over a collection in Python is very slow and should be avoided. If you pass the input values as numpy arrays, this is efficient and almost as fast as using C++, see the [link histogram.benchmarks benchmark].  Here is an example to illustrate:
 
 [python]``
 import histogram as bh
@@ -201,10 +202,12 @@ for i in range(10):
 	h.fill(i)
 
 # do this instead, it is very fast
-v = np.arange(10)
+v = np.arange(10, dtype=float)
 h.fill(v) # fills the histogram with each value in the array
 ``
 
+`fill(...)` accepts any sequence that can be converted into a numpy array with `dtype=float`. To get the best performance, avoid the conversion and work with such numpy arrays directly.
+
 [endsect]
 
 [endsect]
diff --git a/examples/guide_listing_3.cpp b/examples/guide_listing_3.cpp
index 227ea475..93d4d5de 100644
--- a/examples/guide_listing_3.cpp
+++ b/examples/guide_listing_3.cpp
@@ -3,7 +3,7 @@
 namespace bh = boost::histogram;
 
 int main() {
-	// create a 1d-histogram for dice throws, eyes are always between 1 and 6
-	auto h = bh::make_static_histogram(bh::axis::integer<>(1, 6, "eyes", bh::axis::uoflow::off));
+	// create a 1d-histogram for dice throws with eye values from 1 to 6
+	auto h = bh::make_static_histogram(bh::axis::integer<>(1, 7, "eyes", bh::axis::uoflow::off));
 	// do something with h
 }
diff --git a/include/boost/histogram/detail/weight.hpp b/include/boost/histogram/detail/weight.hpp
index ed14ac9d..10d1bed8 100644
--- a/include/boost/histogram/detail/weight.hpp
+++ b/include/boost/histogram/detail/weight.hpp
@@ -20,6 +20,8 @@ struct weight {
   weight &operator=(const weight &) = default;
   weight &operator=(weight &&) = default;
 
+  weight(double value, double variance) : w(value), w2(variance) {}
+
   weight &operator+=(const weight &rhs) {
     w += rhs.w;
     w2 += rhs.w2;
@@ -31,6 +33,12 @@ struct weight {
     return *this;
   }
 
+  weight &operator*=(const double x) {
+    w *= x;
+    w2 *= x;
+    return *this;
+  }
+
   bool operator==(const weight &rhs) const {
     return w == rhs.w && w2 == rhs.w2;
   }
@@ -49,7 +57,7 @@ struct weight {
   }
 
   template <typename T>
-  explicit weight(const T &t) : w(static_cast<double>(t)), w2(w) {}
+  explicit weight(const T &t) : w(static_cast<double>(t)), w2(static_cast<double>(t)) {}
 
   template <typename T> weight &operator=(const T &t) {
     w = static_cast<double>(t);
diff --git a/include/boost/histogram/histogram_fwd.hpp b/include/boost/histogram/histogram_fwd.hpp
index 467819cd..08684784 100644
--- a/include/boost/histogram/histogram_fwd.hpp
+++ b/include/boost/histogram/histogram_fwd.hpp
@@ -20,10 +20,9 @@ namespace histogram {
 using Static = std::integral_constant<int, 0>;
 using Dynamic = std::integral_constant<int, 1>;
 
-template <template <class> class Allocator = std::allocator>
 class adaptive_storage;
 
-template <class Variant, class Axes, class Storage = adaptive_storage<>>
+template <class Variant, class Axes, class Storage = adaptive_storage>
 class histogram;
 
 struct weight {
diff --git a/include/boost/histogram/histogram_impl_dynamic.hpp b/include/boost/histogram/histogram_impl_dynamic.hpp
index 3fbe9d85..596fa6bd 100644
--- a/include/boost/histogram/histogram_impl_dynamic.hpp
+++ b/include/boost/histogram/histogram_impl_dynamic.hpp
@@ -113,11 +113,14 @@ public:
 
   template <typename D, typename A, typename S>
   histogram &operator+=(const histogram<D, A, S> &rhs) {
-    if (!detail::axes_equal(axes_, rhs.axes_)) {
+    if (!detail::axes_equal(axes_, rhs.axes_))
       throw std::logic_error("axes of histograms differ");
-    }
-    for (std::size_t i = 0, n = storage_.size(); i < n; ++i)
-      storage_.add(i, rhs.storage_.value(i), rhs.storage_.variance(i));
+    storage_ += rhs.storage_;
+    return *this;
+  }
+
+  histogram &operator*=(const value_type rhs) {
+    storage_ *= rhs;
     return *this;
   }
 
@@ -152,7 +155,7 @@ public:
     std::size_t idx = 0, stride = 1;
     xlin_iter(idx, stride, begin);
     if (stride) {
-      storage_.increase(idx, n.value);
+      storage_.add(idx, n.value);
     }
   }
 
@@ -270,7 +273,7 @@ private:
     unsigned n = 0;
     xlin_n<0>(idx, stride, n, std::forward<Args>(args)...);
     if (stride) {
-      storage_.increase(idx, n);
+      storage_.add(idx, n);
     }
   }
 
diff --git a/include/boost/histogram/histogram_impl_static.hpp b/include/boost/histogram/histogram_impl_static.hpp
index 4b8186a5..ddd4cd7b 100644
--- a/include/boost/histogram/histogram_impl_static.hpp
+++ b/include/boost/histogram/histogram_impl_static.hpp
@@ -96,8 +96,7 @@ public:
     if (!detail::axes_equal(axes_, rhs.axes_)) {
       throw std::logic_error("axes of histograms differ");
     }
-    for (std::size_t i = 0, n = storage_.size(); i < n; ++i)
-      storage_.add(i, rhs.storage_.value(i), rhs.storage_.variance(i));
+    storage_ += rhs.storage_;
     return *this;
   }
 
@@ -201,7 +200,7 @@ private:
     unsigned n = 0;
     xlin_n<0>(idx, stride, n, std::forward<Args>(args)...);
     if (stride) {
-      storage_.increase(idx, n);
+      storage_.add(idx, n);
     }
   }
 
diff --git a/include/boost/histogram/serialization.hpp b/include/boost/histogram/serialization.hpp
index 4da42a1e..c867579c 100644
--- a/include/boost/histogram/serialization.hpp
+++ b/include/boost/histogram/serialization.hpp
@@ -49,17 +49,17 @@ void serialize(Archive &ar, array_storage<Container> &store,
   ar &store.array_;
 }
 
-template <template <class> class Allocator>
 template <class Archive>
-void adaptive_storage<Allocator>::serialize(Archive &ar,
+void adaptive_storage::serialize(Archive &ar,
                                             unsigned /* version */) {
+  using detail::array;
   std::size_t size = this->size();
   ar &size;
   if (Archive::is_loading::value) {
     unsigned tid = 0;
     ar &tid;
     if (tid == 0) {
-      buffer_ = array<void>(size);
+      buffer_ = detail::array<void>(size);
     } else if (tid == 1) {
       array<uint8_t> a(size);
       ar &serialization::make_array(a.begin(), size);
@@ -77,11 +77,11 @@ void adaptive_storage<Allocator>::serialize(Archive &ar,
       ar &serialization::make_array(a.begin(), size);
       buffer_ = std::move(a);
     } else if (tid == 5) {
-      array<mp_int> a(size);
+      array<detail::mp_int> a(size);
       ar &serialization::make_array(a.begin(), size);
       buffer_ = std::move(a);
     } else if (tid == 6) {
-      array<weight> a(size);
+      array<detail::weight> a(size);
       ar &serialization::make_array(a.begin(), size);
       buffer_ = std::move(a);
     }
@@ -106,11 +106,11 @@ void adaptive_storage<Allocator>::serialize(Archive &ar,
       tid = 4;
       ar &tid;
       ar &serialization::make_array(a->begin(), size);
-    } else if (array<mp_int> *a = get<array<mp_int>>(&buffer_)) {
+    } else if (array<detail::mp_int> *a = get<array<detail::mp_int>>(&buffer_)) {
       tid = 5;
       ar &tid;
       ar &serialization::make_array(a->begin(), size);
-    } else if (array<weight> *a = get<array<weight>>(&buffer_)) {
+    } else if (array<detail::weight> *a = get<array<detail::weight>>(&buffer_)) {
       tid = 6;
       ar &tid;
       ar &serialization::make_array(a->begin(), size);
diff --git a/include/boost/histogram/storage/adaptive_storage.hpp b/include/boost/histogram/storage/adaptive_storage.hpp
index 1c72dc47..6785daf4 100644
--- a/include/boost/histogram/storage/adaptive_storage.hpp
+++ b/include/boost/histogram/storage/adaptive_storage.hpp
@@ -15,6 +15,7 @@
 #include <boost/multiprecision/cpp_int.hpp>
 #include <boost/variant.hpp>
 #include <limits>
+#include <memory>
 #include <type_traits>
 
 // forward declaration for serialization
@@ -40,7 +41,7 @@ using mp_int = multiprecision::cpp_int;
 
 class array_base {
 public:
-  array_base(const std::size_t s) : size(s) {}
+  explicit array_base(const std::size_t s) : size(s) {}
   array_base() = default;
   array_base(const array_base &) = default;
   array_base &operator=(const array_base &) = default;
@@ -55,112 +56,347 @@ public:
   std::size_t size = 0;
 };
 
-template <template <class> class Allocator, typename T>
-class array : public array_base, public Allocator<T> {
+template <typename T>
+class array : public array_base {
 public:
-  using value_type = T;
-  array(const std::size_t s) : array_base(s) {
-    create();
+  explicit array(const std::size_t s) : array_base(s), ptr(new T[s]) {
     std::fill(begin(), end(), T(0));
   }
   array() = default;
-  array(const array &rhs) : array_base(rhs), Allocator<T>(rhs) {
-    create();
+  array(const array &rhs) : array_base(rhs), ptr(new T[rhs.size]) {
     std::copy(rhs.begin(), rhs.end(), begin());
   }
   array &operator=(const array &rhs) {
     if (this != &rhs) {
       if (size != rhs.size) {
-        destroy();
-        Allocator<T>::operator=(rhs);
         size = rhs.size;
-        create();
+        ptr.reset(new T[size]);
       }
       std::copy(rhs.begin(), rhs.end(), begin());
     }
     return *this;
   }
   array(array &&rhs)
-      : array_base(std::move(rhs)), Allocator<T>(std::move(rhs)), ptr(rhs.ptr) {
+      : array_base(std::move(rhs)), ptr(std::move(rhs.ptr)) {
+    rhs.size = 0;
   }
   array &operator=(array &&rhs) {
     if (this != &rhs) {
       size = rhs.size;
-      Allocator<T>::operator=(std::move(rhs));
-      ptr = rhs.ptr;
+      ptr = std::move(rhs.ptr);
       rhs.size = 0;
     }
     return *this;
   }
-  ~array() { destroy(); }
 
   // copy only up to nmax elements
   template <typename U>
-  array(const array<Allocator, U> &rhs,
+  array(const array<U> &rhs,
         std::size_t nmax = std::numeric_limits<std::size_t>::max())
-      : array_base(rhs), Allocator<T>(rhs) {
-    create();
+      : array_base(rhs), ptr(new T[rhs.size]) {
     std::copy(rhs.begin(), rhs.begin() + std::min(nmax, size), begin());
   }
 
   T &operator[](const std::size_t i) { return ptr[i]; }
   const T &operator[](const std::size_t i) const { return ptr[i]; }
 
-  T *begin() { return ptr; }
-  T *end() { return ptr + size; }
-  const T *begin() const { return ptr; }
-  const T *end() const { return ptr + size; }
+  T *begin() { return ptr.get(); }
+  T *end() { return ptr.get() + size; }
+  const T *begin() const { return ptr.get(); }
+  const T *end() const { return ptr.get() + size; }
 
 private:
-  void create() {
-    if (size) {
-      ptr = Allocator<T>::allocate(size);
-      if (!std::is_pod<T>::value) {
-        new (ptr) T[size];
-      }
-    }
-  }
-  void destroy() {
-    if (size) {
-      if (!std::is_pod<T>::value) {
-        for (auto it = begin(); it != end(); ++it) {
-          it->~T();
-        }
-      }
-      Allocator<T>::deallocate(ptr, size);
-    }
-  }
-  T *ptr = nullptr;
+  std::unique_ptr<T[]> ptr;
 };
 
-template <template <class> class Allocator>
-class array<Allocator, void> : public array_base {
+template <>
+class array<void> : public array_base {
 public:
-  using value_type = void;
   using array_base::array_base;
 };
 
+using any_array =
+      variant<array<void>,
+              array<uint8_t>,
+              array<uint16_t>,
+              array<uint32_t>,
+              array<uint64_t>,
+              array<mp_int>,
+              array<weight>>;
+
 template <typename T> struct next_type;
 template <> struct next_type<uint8_t> { using type = uint16_t; };
 template <> struct next_type<uint16_t> { using type = uint32_t; };
 template <> struct next_type<uint32_t> { using type = uint64_t; };
 template <> struct next_type<uint64_t> { using type = mp_int; };
+template <typename T> using next = typename next_type<T>::type;
+
+template <typename T>
+inline bool safe_increase(T& t) {
+  if (t == std::numeric_limits<T>::max())
+    return false;
+  ++t;
+  return true;
+}
+
+template <typename T, typename U>
+inline bool safe_assign(T& t, const U& u) {
+  if (std::numeric_limits<T>::max() < std::numeric_limits<U>::max() &&
+      std::numeric_limits<T>::max() < u)
+    return false;
+  t = static_cast<T>(u);
+  return true;
+}
+
+template <typename T, typename U>
+inline bool safe_radd(T& t, const U& u) {
+  if ((std::numeric_limits<T>::max() - t) < u)
+    return false;
+  t += static_cast<T>(u);
+  return true;
+}
+
+// WTF is this needed?
+template <typename T>
+inline bool safe_radd(T& t, const double u) {
+  if ((std::numeric_limits<T>::max() - t) <= u)
+    return false;
+  t += u;
+  return true;
+}
+
+template <typename T>
+inline bool safe_rmul(T& t, const uint64_t x) {
+  if ((x * t) > std::numeric_limits<T>::max())
+    return false;
+  t *= x;
+  return true;
+}
+
+struct size_visitor : public static_visitor<std::size_t> {
+  template <typename Array> std::size_t operator()(const Array &b) const {
+    return b.size;
+  }
+};
+
+template <typename RHS>
+struct assign_visitor : public static_visitor<void> {
+  any_array &lhs_any;
+  const std::size_t idx;
+  const RHS &rhs;
+  assign_visitor(any_array &a, const std::size_t i, const RHS &x)
+      : lhs_any(a), idx(i), rhs(x) {}
+
+  template <typename T> void operator()(array<T> &lhs) const {
+    if (!safe_assign(lhs[idx], rhs)) {
+      lhs_any = array<next<T>>(lhs, idx);
+      operator()(get<array<next<T>>>(lhs_any));
+    }
+  }
+
+  void operator()(array<void> &lhs) const {
+    lhs_any = array<uint8_t>(lhs.size);
+    operator()(get<array<uint8_t>>(lhs_any));
+  }
+
+  void operator()(array<mp_int> &lhs) const {
+    lhs[idx].assign(rhs);
+  }
+
+  void operator()(array<weight> &lhs) const { lhs[idx] = rhs; }
+};
+
+struct increase_visitor : public static_visitor<void> {
+  any_array &lhs_any;
+  const std::size_t idx;
+  increase_visitor(any_array& a, const std::size_t i)
+      : lhs_any(a), idx(i) {}
+
+  template <typename T> void operator()(array<T> &lhs) const {
+    if (!safe_increase(lhs[idx])) {
+      array<next<T>> a = lhs;
+      ++a[idx];
+      lhs_any = std::move(a);
+    }
+  }
+
+  void operator()(array<void> &lhs) const {
+    array<uint8_t> a(lhs.size);
+    ++a[idx];
+    lhs_any = std::move(a);
+  }
+
+  void operator()(array<mp_int> &lhs) const { ++lhs[idx]; }
+
+  void operator()(array<weight> &lhs) const { ++lhs[idx]; }
+};
+
+struct wincrease_visitor : public static_visitor<void> {
+  any_array &lhs_any;
+  const std::size_t idx;
+  const double rhs;
+  wincrease_visitor(any_array &l, const std::size_t i, const double r)
+      : lhs_any(l), idx(i), rhs(r) {}
+
+  template <typename T> void operator()(array<T> &lhs) const {
+    array<weight> a(lhs);
+    a[idx].add_weight(rhs);
+    lhs_any = std::move(a);
+  }
+
+  void operator()(array<void> &lhs) const {
+    array<weight> a(lhs.size);
+    a[idx].add_weight(rhs);
+    lhs_any = std::move(a);
+  }
+
+  void operator()(array<weight> &lhs) const { lhs[idx].add_weight(rhs); }
+};
+
+struct value_visitor : public static_visitor<double> {
+  const std::size_t idx;
+  value_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<weight> &b) const {
+    return b[idx].w;
+  }
+};
+
+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<weight> &b) const {
+    return b[idx].w2;
+  }
+};
+
+template <typename RHS> struct radd_visitor : public static_visitor<void> {
+  any_array &lhs_any;
+  const std::size_t idx;
+  const RHS &rhs;
+  radd_visitor(any_array &l, const std::size_t i, const RHS &r)
+      : lhs_any(l), idx(i), rhs(r) {}
+
+  template <typename T> void operator()(array<T> &lhs) const {
+    if (!safe_radd(lhs[idx], rhs)) {
+      lhs_any = array<next<T>>(lhs);
+      operator()(get<array<next<T>>>(lhs_any));
+    }
+  }
+
+  void operator()(array<void> &lhs) const {
+    if (rhs != 0) {
+      lhs_any = array<uint8_t>(lhs.size);
+      operator()(get<array<uint8_t>>(lhs_any));
+    }
+  }
+
+  void operator()(array<mp_int> &lhs) const {
+    lhs[idx] += static_cast<mp_int>(rhs);
+  }
+
+  void operator()(array<weight> &lhs) const { lhs[idx] += rhs; }
+};
+
+
+template <> struct radd_visitor<weight> : public static_visitor<void> {
+  any_array &lhs_any;
+  const std::size_t idx;
+  const weight &rhs;
+  radd_visitor(any_array &l, const std::size_t i, const weight &r)
+      : lhs_any(l), idx(i), rhs(r) {}
+
+  template <typename T> void operator()(array<T> &lhs) const {
+    lhs_any = array<weight>(lhs);
+    operator()(get<array<weight>>(lhs_any));
+  }
+
+  void operator()(array<void> &lhs) const {
+    lhs_any = array<weight>(lhs.size);
+    operator()(get<array<weight>>(lhs_any));
+  }
+
+  void operator()(array<weight> &lhs) const {
+    lhs[idx] += rhs;
+  }
+};
+
+// precondition: both arrays must have same size and may not be identical
+struct radd_array_visitor : public static_visitor<void> {
+  any_array& lhs_any;
+  radd_array_visitor(any_array& l) : lhs_any(l) {}
+  template <typename T> void operator()(const array<T> &rhs) const {
+    for (auto i = 0ul; i < rhs.size; ++i)
+      apply_visitor(radd_visitor<T>(lhs_any, i, rhs[i]), lhs_any);
+  }
+  void operator()(const array<void> &rhs) const {}
+};
+
+struct rmul_visitor : public static_visitor<void> {
+  any_array& lhs_any;
+  const double x;
+  rmul_visitor(any_array& l, const double v) : lhs_any(l), x(v) {}
+  template <typename T> void operator()(array<T>& lhs) const {
+    lhs_any = array<weight>(lhs);
+    operator()(get<array<weight>>(lhs_any));
+  }
+  void operator()(array<void>&) const {}
+  void operator()(array<weight>& lhs) const {
+    for (auto i = 0ul; i != lhs.size; ++i)
+      lhs[i] *= x;
+  }
+};
+
+struct bicmp_visitor : public static_visitor<bool> {
+  template <typename Array1, typename Array2>
+  bool operator()(const Array1 &b1, const Array2 &b2) const {
+    if (b1.size != b2.size)
+      return false;
+    return std::equal(b1.begin(), b1.end(), b2.begin());
+  }
+
+  template <typename T>
+  bool operator()(const array<T> &b1, const array<void> &b2) const {
+    if (b1.size != b2.size)
+      return false;
+    return std::all_of(b1.begin(), b1.end(), [](const T& t) { return t == 0; });
+  }
+
+  template <typename T>
+  bool operator()(const array<void> &b1, const array<T> &b2) const {
+    return operator()(b2, b1);
+  }
+
+  bool operator()(const array<void> &b1, const array<void> &b2) const {
+    return b1.size == b2.size;
+  }
+};
 
 } // namespace detail
 
-template <template <class> class Allocator> class adaptive_storage {
-  template <typename T> using array = detail::array<Allocator, T>;
-  template <typename T> using next = typename detail::next_type<T>::type;
-  using weight = detail::weight;
-  using mp_int = detail::mp_int;
-  using buffer_type =
-      variant<array<void>, array<uint8_t>, array<uint16_t>, array<uint32_t>,
-              array<uint64_t>, array<mp_int>, array<weight>>;
-
+class adaptive_storage {
+  using buffer_type = detail::any_array;
 public:
   using value_type = double;
 
-  explicit adaptive_storage(std::size_t s) : buffer_(array<void>(s)) {}
+  explicit adaptive_storage(std::size_t s) : buffer_(detail::array<void>(s)) {}
 
   adaptive_storage() = default;
   adaptive_storage(const adaptive_storage &) = default;
@@ -169,261 +405,92 @@ public:
   adaptive_storage &operator=(adaptive_storage &&) = default;
 
   template <typename RHS, typename = detail::is_storage<RHS>>
-  explicit adaptive_storage(const RHS &rhs) : buffer_(array<void>(rhs.size())) {
+  explicit adaptive_storage(const RHS &rhs) : buffer_(detail::array<void>(rhs.size())) {
+    using T = typename RHS::value_type;
     for (auto i = 0ul, n = rhs.size(); i < n; ++i) {
       apply_visitor(
-          assign_visitor<typename RHS::value_type>(i, rhs.value(i), buffer_),
+          detail::assign_visitor<T>(buffer_, i, rhs.value(i)),
           buffer_);
     }
   }
 
   template <typename RHS> adaptive_storage &operator=(const RHS &rhs) {
+    using T = typename RHS::value_type;
     if (static_cast<const void *>(this) != static_cast<const void *>(&rhs)) {
-      if (size() != rhs.size()) {
-        buffer_ = array<void>(rhs.size());
+      const auto n = rhs.size();
+      if (size() != n) {
+        buffer_ = detail::array<void>(n);
       }
-      for (auto i = 0ul, n = rhs.size(); i < n; ++i) {
+      for (auto i = 0ul; i < n; ++i) {
         apply_visitor(
-            assign_visitor<typename RHS::value_type>(i, rhs.value(i), buffer_),
+            detail::assign_visitor<T>(buffer_, i, rhs.value(i)),
             buffer_);
       }
     }
     return *this;
   }
 
-  std::size_t size() const { return apply_visitor(size_visitor(), buffer_); }
+  std::size_t size() const { return apply_visitor(detail::size_visitor(), buffer_); }
 
   void increase(std::size_t i) {
-    apply_visitor(increase_visitor(i, buffer_), buffer_);
+    apply_visitor(detail::increase_visitor(buffer_, i), buffer_);
   }
 
-  template <typename Value> void increase(std::size_t i, const Value &n) {
-    apply_visitor(add_visitor<Value>(i, n, buffer_), buffer_);
+  template <typename T> void add(std::size_t i, const T &value) {
+    apply_visitor(detail::radd_visitor<T>(buffer_, i, value), buffer_);
   }
 
-  void weighted_increase(std::size_t i, value_type weight) {
-    apply_visitor(wincrease_visitor(i, weight, buffer_), buffer_);
-  }
-
-  void add(std::size_t i, const value_type &val, const value_type &var) {
-    if (val == var) {
-      apply_visitor(add_visitor<value_type>(i, val, buffer_), buffer_);
+  template <typename T>
+  void add(std::size_t i, const T& value, const T& variance) {
+    if (value == variance) {
+      apply_visitor(detail::radd_visitor<T>(buffer_, i, value), buffer_);
     } else {
-      if (!boost::get<array<weight>>(&buffer_)) {
-        apply_visitor(wincrease_visitor(0, 0.0, buffer_), buffer_);
-      }
-      auto &b = boost::get<array<weight>>(buffer_);
-      b[i].w += val;
-      b[i].w2 += var;
+      apply_visitor(detail::radd_visitor<detail::weight>(buffer_, i, detail::weight(value, variance)), buffer_);
     }
   }
 
+  void weighted_increase(std::size_t i, const double weight) {
+    apply_visitor(detail::wincrease_visitor(buffer_, i, weight), buffer_);
+  }
+
   value_type value(std::size_t i) const {
-    return apply_visitor(value_visitor(i), buffer_);
+    return apply_visitor(detail::value_visitor(i), buffer_);
   }
 
   value_type variance(std::size_t i) const {
-    return apply_visitor(variance_visitor(i), buffer_);
+    return apply_visitor(detail::variance_visitor(i), buffer_);
   }
 
   bool operator==(const adaptive_storage &rhs) const {
-    return apply_visitor(bicmp_visitor(), buffer_, rhs.buffer_);
+    return apply_visitor(detail::bicmp_visitor(), buffer_, rhs.buffer_);
+  }
+
+  // precondition: storages have same size
+  adaptive_storage& operator+=(const adaptive_storage& rhs) {
+    if (this == &rhs) {
+      for (auto i = 0ul, n = size(); i < n; ++i)
+        add(i, rhs.value(i), rhs.variance(i)); // this is losing precision
+    }
+    else {
+      apply_visitor(detail::radd_array_visitor(buffer_), rhs.buffer_);
+    }
+    return *this;
+  }
+
+  // precondition: storages have same size
+  template <typename RHS, typename = detail::is_storage<RHS>>
+  adaptive_storage& operator+=(const RHS& rhs) {
+    for (auto i = 0ul, n = size(); i < n; ++i)
+      apply_visitor(detail::radd_visitor<typename RHS::value_type>(buffer_, i, rhs.value(i)), buffer_);
+    return *this;
+  }
+
+  adaptive_storage& operator*=(const value_type x) {
+    apply_visitor(detail::rmul_visitor(buffer_, x), buffer_);
+    return *this;
   }
 
 private:
-  struct size_visitor : public static_visitor<std::size_t> {
-    template <typename Array> std::size_t operator()(const Array &b) const {
-      return b.size;
-    }
-  };
-
-  template <typename Value>
-  struct assign_visitor : public static_visitor<void> {
-    const std::size_t &idx;
-    const Value &value;
-    buffer_type &buffer;
-    assign_visitor(const std::size_t &i, const Value &v, buffer_type &b)
-        : idx(i), value(v), buffer(b) {}
-
-    template <typename Array> void operator()(Array &b) const {
-      using T = typename Array::value_type;
-      if (value <= std::numeric_limits<T>::max()) {
-        b[idx] = value;
-      } else {
-        buffer = array<next<T>>(b, idx);
-        (*this)(get<array<next<T>>>(buffer));
-      }
-    }
-
-    void operator()(array<void> &b) const {
-      auto a = array<uint8_t>(b.size);
-      (*this)(a);
-      buffer = a;
-    }
-
-    void operator()(array<mp_int> &b) const {
-      b[idx] = static_cast<mp_int>(value);
-    }
-
-    void operator()(array<weight> &b) const { b[idx] = value; }
-  };
-
-  struct increase_visitor : public static_visitor<void> {
-    const std::size_t &idx;
-    buffer_type &buffer;
-    increase_visitor(const std::size_t &i, buffer_type &b)
-        : idx(i), buffer(b) {}
-
-    template <typename Array> void operator()(Array &b) const {
-      using T = typename Array::value_type;
-      T &x = b[idx];
-      if (x < std::numeric_limits<T>::max()) {
-        ++x;
-      } else {
-        array<next<T>> nb = b;
-        ++nb[idx];
-        buffer = std::move(nb);
-      }
-    }
-
-    void operator()(array<void> &b) const {
-      array<uint8_t> nb(b.size);
-      ++nb[idx];
-      buffer = std::move(nb);
-    }
-
-    void operator()(array<mp_int> &b) const { ++b[idx]; }
-
-    void operator()(array<weight> &b) const { ++b[idx]; }
-  };
-
-  struct wincrease_visitor : public static_visitor<void> {
-    const std::size_t &idx;
-    const value_type &w;
-    buffer_type &buffer;
-    wincrease_visitor(const std::size_t &i, const value_type &v, buffer_type &b)
-        : idx(i), w(v), buffer(b) {}
-
-    template <typename Array> void operator()(Array &b) const {
-      array<weight> nb(b);
-      nb[idx].add_weight(w);
-      buffer = std::move(nb);
-    }
-
-    void operator()(array<void> &b) const {
-      array<weight> nb(b.size);
-      nb[idx].add_weight(w);
-      buffer = std::move(nb);
-    }
-
-    void operator()(array<weight> &b) const { b[idx].add_weight(w); }
-  };
-
-  struct value_visitor : public static_visitor<value_type> {
-    const std::size_t &idx;
-    value_visitor(const std::size_t &i) : idx(i) {}
-
-    template <typename Array> value_type operator()(const Array &b) const {
-      return static_cast<value_type>(b[idx]);
-    }
-
-    value_type operator()(const array<void> & /*b*/) const {
-      return value_type(0);
-    }
-
-    value_type operator()(const array<weight> &b) const {
-      return static_cast<value_type>(b[idx].w);
-    }
-  };
-
-  struct variance_visitor : public static_visitor<value_type> {
-    const std::size_t &idx;
-    variance_visitor(const std::size_t &i) : idx(i) {}
-
-    template <typename Array> value_type operator()(const Array &b) const {
-      return static_cast<value_type>(b[idx]);
-    }
-
-    value_type operator()(const array<void> & /*b*/) const {
-      return value_type(0);
-    }
-
-    value_type operator()(const array<weight> &b) const {
-      return static_cast<value_type>(b[idx].w2);
-    }
-  };
-
-  template <typename Value> struct add_visitor : public static_visitor<void> {
-    const std::size_t &idx;
-    const Value &value;
-    buffer_type &buffer;
-    add_visitor(const std::size_t &i, const Value &v, buffer_type &b)
-        : idx(i), value(v), buffer(b) {}
-
-    template <typename Array> void operator()(Array &b) const {
-      using T = typename Array::value_type;
-      T &x = b[idx];
-      if (static_cast<T>(std::numeric_limits<T>::max() - x) > value) {
-        x += value;
-      } else {
-        buffer = array<next<T>>(b);
-        (*this)(get<array<next<T>>>(buffer));
-      }
-    }
-
-    void operator()(array<void> &b) const {
-      if (value > 0) {
-        buffer = array<uint8_t>(b.size);
-        operator()(get<array<uint8_t>>(buffer));
-      }
-    }
-
-    void operator()(array<mp_int> &b) const {
-      b[idx] += static_cast<mp_int>(value);
-    }
-
-    void operator()(array<weight> &b) const { b[idx] += value; }
-  };
-
-  struct bicmp_visitor : public static_visitor<bool> {
-    template <typename Array1, typename Array2>
-    bool operator()(const Array1 &b1, const Array2 &b2) const {
-      if (b1.size != b2.size)
-        return false;
-      for (std::size_t i = 0; i < b1.size; ++i) {
-        if (b1[i] != b2[i])
-          return false;
-      }
-      return true;
-    }
-
-    template <typename Array>
-    bool operator()(const Array &b1, const array<void> &b2) const {
-      if (b1.size != b2.size)
-        return false;
-      for (std::size_t i = 0; i < b1.size; ++i) {
-        if (b1[i] != 0)
-          return false;
-      }
-      return true;
-    }
-
-    template <typename Array>
-    bool operator()(const array<void> &b1, const Array &b2) const {
-      if (b1.size != b2.size)
-        return false;
-      for (std::size_t i = 0; i < b1.size; ++i) {
-        if (b2[i] != 0)
-          return false;
-      }
-      return true;
-    }
-
-    bool operator()(const array<void> &b1, const array<void> &b2) const {
-      return b1.size == b2.size;
-    }
-  };
-
   buffer_type buffer_;
 
   friend class ::boost::python::access;
diff --git a/include/boost/histogram/storage/array_storage.hpp b/include/boost/histogram/storage/array_storage.hpp
index 00b168b5..7422e779 100644
--- a/include/boost/histogram/storage/array_storage.hpp
+++ b/include/boost/histogram/storage/array_storage.hpp
@@ -74,19 +74,29 @@ public:
 
   std::size_t size() const noexcept { return size_; }
   void increase(std::size_t i) noexcept { ++array_[i]; }
-  template <typename Value>
-  void increase(std::size_t i, const Value &n) noexcept {
+  void add(std::size_t i, const value_type& n) noexcept {
     array_[i] += n;
   }
-
-  void add(std::size_t i, const value_type &val,
-           const value_type & /* var */) noexcept {
-    array_[i] += val;
+  void add(std::size_t i, const value_type& n, const value_type& /* variance */) noexcept {
+    array_[i] += n;
   }
 
   value_type value(std::size_t i) const noexcept { return array_[i]; }
   value_type variance(std::size_t i) const noexcept { return array_[i]; }
 
+  template <typename U>
+  array_storage& operator+=(const array_storage<U>& rhs) noexcept {
+    for (auto i = 0ul; i < size_; ++i)
+      array_[i] += rhs.array_[i];
+    return *this;
+  }
+
+  array_storage& operator*=(const value_type x) noexcept {
+    for (auto i = 0ul; i < size_; ++i)
+      array_[i] *= x;
+    return *this;
+  }
+
 private:
   std::size_t size_ = 0;
   std::unique_ptr<T[]> array_;
diff --git a/src/python/histogram.cpp b/src/python/histogram.cpp
index c5916ddd..ef4f42ae 100644
--- a/src/python/histogram.cpp
+++ b/src/python/histogram.cpp
@@ -29,7 +29,7 @@ namespace np = boost::python::numpy;
 namespace boost {
 
 namespace histogram {
-using dynamic_histogram = histogram<Dynamic, builtin_axes, adaptive_storage<>>;
+using dynamic_histogram = histogram<Dynamic, builtin_axes, adaptive_storage>;
 } // namespace histogram
 
 namespace python {
@@ -37,18 +37,18 @@ namespace python {
 #ifdef HAVE_NUMPY
 class access {
 public:
-  using mp_int = histogram::adaptive_storage<>::mp_int;
-  using weight = histogram::adaptive_storage<>::weight;
+  using mp_int = histogram::detail::mp_int;
+  using weight = histogram::detail::weight;
   template <typename T>
-  using array = histogram::adaptive_storage<>::array<T>;
+  using array = histogram::detail::array<T>;
 
   struct dtype_visitor : public static_visitor<str> {
     list & shapes, & strides;
     dtype_visitor(list &sh, list &st) : shapes(sh), strides(st) {}
-    template <typename Array>
-    str operator()(const Array& /*unused*/) const {
-      strides.append(sizeof(typename Array::value_type));
-      return dtype_typestr<typename Array::value_type>();
+    template <typename T>
+    str operator()(const array<T>& /*unused*/) const {
+      strides.append(sizeof(T));
+      return dtype_typestr<T>();
     }
     str operator()(const array<void>& /*unused*/) const {
       strides.append(sizeof(uint8_t));
@@ -186,8 +186,10 @@ struct fetcher {
   long n = 0;
   union {
     double value = 0;
-    const double* array;
+    const double* carray;
   };
+  python::object keep_alive;
+
   void assign(python::object o) {
     // skipping check for currently held type, since it is always value
     python::extract<double> get_double(o);
@@ -197,20 +199,17 @@ struct fetcher {
       return;
     }
 #ifdef HAVE_NUMPY
-    np::ndarray a = python::extract<np::ndarray>(o);
-    if (a.get_nd() != 1)
-      throw std::invalid_argument("array must be 1 dimensional");
-    if (a.get_dtype() != np::dtype::get_builtin<double>())
-      throw std::invalid_argument("array dtype must be double");
-    array = reinterpret_cast<const double*>(a.get_data());
+    np::ndarray a = np::from_object(o, np::dtype::get_builtin<double>(), 1);
+    carray = reinterpret_cast<const double*>(a.get_data());
     n = a.shape(0);
+    keep_alive = a; // this may be a temporary object
     return;
 #endif
     throw std::invalid_argument("argument must be a number");
   }
   double get(long i) const noexcept {
     if (n > 0)
-      return array[i];
+      return carray[i];
     return value;
   }
 };
diff --git a/test/adaptive_storage_test.cpp b/test/adaptive_storage_test.cpp
index 31619328..868bdda4 100644
--- a/test/adaptive_storage_test.cpp
+++ b/test/adaptive_storage_test.cpp
@@ -17,34 +17,35 @@ namespace boost {
 
 namespace histogram {
 
-template <typename T> adaptive_storage<> prepare(unsigned n = 1) {
-  adaptive_storage<> s(n);
+template <typename T> adaptive_storage prepare(unsigned n = 1) {
+  adaptive_storage s(n);
   s.increase(0);
   const auto tmax = std::numeric_limits<T>::max();
   while (s.value(0) < 0.1 * tmax) {
-    s.increase(0, s.value(0));
+    s.add(0, s.value(0));
   }
   return s;
 }
 
-template <> adaptive_storage<> prepare<void>(unsigned n) {
-  adaptive_storage<> s(n);
+template <> adaptive_storage prepare<void>(unsigned n) {
+  adaptive_storage s(n);
   return s;
 }
 
-template <> adaptive_storage<> prepare<detail::weight>(unsigned n) {
-  adaptive_storage<> s(n);
+template <> adaptive_storage prepare<detail::weight>(unsigned n) {
+  adaptive_storage s(n);
   s.weighted_increase(0, 1.0);
   return s;
 }
 
-template <> adaptive_storage<> prepare<detail::mp_int>(unsigned n) {
-  adaptive_storage<> s(n);
+template <> adaptive_storage prepare<detail::mp_int>(unsigned n) {
+  adaptive_storage s(n);
   s.increase(0);
   auto tmax = static_cast<double>(std::numeric_limits<uint64_t>::max());
   tmax *= 2.0;
   while (s.value(0) < tmax) {
-    s.increase(0, s.value(0));
+    assert(s.value(0) != 0);
+    s.add(0, s.value(0));
   }
   return s;
 }
@@ -55,9 +56,9 @@ namespace python { // cheating to get access
 class access {
 public:
   template <typename T>
-  static histogram::adaptive_storage<> set_value(unsigned n, T x) {
-    histogram::adaptive_storage<> s = histogram::prepare<T>(n);
-    get<histogram::adaptive_storage<>::array<T>>(s.buffer_)[0] = x;
+  static histogram::adaptive_storage set_value(unsigned n, T x) {
+    histogram::adaptive_storage s = histogram::prepare<T>(n);
+    get<histogram::detail::array<T>>(s.buffer_)[0] = x;
     return s;
   }
 };
@@ -92,7 +93,7 @@ template <typename T> void serialization_impl() {
     oa << a;
     buf = os.str();
   }
-  adaptive_storage<> b;
+  adaptive_storage b;
   BOOST_TEST(!(a == b));
   {
     std::istringstream is(buf);
@@ -103,7 +104,7 @@ template <typename T> void serialization_impl() {
 }
 
 template <> void serialization_impl<void>() {
-  adaptive_storage<> a(1);
+  adaptive_storage a(1);
   std::ostringstream os;
   std::string buf;
   {
@@ -112,7 +113,7 @@ template <> void serialization_impl<void>() {
     oa << a;
     buf = os.str();
   }
-  adaptive_storage<> b;
+  adaptive_storage b;
   BOOST_TEST(!(a == b));
   {
     std::istringstream is(buf);
@@ -123,7 +124,7 @@ template <> void serialization_impl<void>() {
 }
 
 template <typename T> void equal_impl() {
-  adaptive_storage<> a(1);
+  adaptive_storage a(1);
   auto b = python::access::set_value(1, T(0));
   BOOST_TEST_EQ(a.value(0), 0.0);
   BOOST_TEST_EQ(a.variance(0), 0.0);
@@ -139,7 +140,7 @@ template <typename T> void equal_impl() {
 }
 
 template <> void equal_impl<void>() {
-  adaptive_storage<> a(1);
+  adaptive_storage a(1);
   auto b = python::access::set_value(1, uint8_t(0));
   auto c = python::access::set_value(2, uint8_t(0));
   auto d = array_storage<unsigned>(1);
@@ -168,10 +169,10 @@ template <typename T> void increase_and_grow_impl() {
   n.increase(0);
   n.increase(0);
 
-  adaptive_storage<> x(2);
+  adaptive_storage x(2);
   x.increase(0);
-  n2.increase(0, x.value(0));
-  n2.increase(0, x.value(0));
+  n2.add(0, x.value(0));
+  n2.add(0, x.value(0));
 
   double v = tmax;
   ++v;
@@ -182,7 +183,7 @@ template <typename T> void increase_and_grow_impl() {
 }
 
 template <> void increase_and_grow_impl<void>() {
-  adaptive_storage<> s(2);
+  adaptive_storage s(2);
   s.increase(0);
   BOOST_TEST_EQ(s.value(0), 1.0);
   BOOST_TEST_EQ(s.value(1), 0.0);
@@ -200,14 +201,14 @@ template <typename T> void convert_array_storage_impl() {
   a.increase(0);
   BOOST_TEST(!(a == s));
 
-  adaptive_storage<> b(s);
+  adaptive_storage b(s);
   BOOST_TEST_EQ(b.value(0), 1.0);
   BOOST_TEST(b == s);
   b.increase(0);
   BOOST_TEST(!(b == s));
 
   auto c = aref;
-  c.increase(0, s.value(0));
+  c.add(0, s.value(0));
   BOOST_TEST_EQ(c.value(0), 1.0);
   BOOST_TEST(c == s);
   BOOST_TEST(s == c);
@@ -215,7 +216,7 @@ template <typename T> void convert_array_storage_impl() {
   array_storage<float> t(1);
   t.increase(0);
   while (t.value(0) < 1e20)
-    t.increase(0, t.value(0));
+    t.add(0, t.value(0));
   auto d = aref;
   d = t;
   BOOST_TEST(d == t);
@@ -227,14 +228,14 @@ template <typename T> void convert_array_storage_impl() {
   e.increase(0);
   BOOST_TEST(!(e == s));
 
-  adaptive_storage<> f(s);
+  adaptive_storage f(s);
   BOOST_TEST_EQ(f.value(0), 1.0);
   BOOST_TEST(f == s);
   f.increase(0);
   BOOST_TEST(!(f == s));
 
   auto g = aref;
-  g.increase(0, s.value(0));
+  g.add(0, s.value(0));
   BOOST_TEST_EQ(g.value(0), 1.0);
   BOOST_TEST(g == s);
   BOOST_TEST(s == g);
@@ -248,7 +249,7 @@ template <typename T> void convert_array_storage_impl() {
 }
 
 template <> void convert_array_storage_impl<void>() {
-  const auto aref = adaptive_storage<>(1);
+  const auto aref = adaptive_storage(1);
   BOOST_TEST_EQ(aref.value(0), 0.0);
   array_storage<uint8_t> s(1);
   s.increase(0);
@@ -261,7 +262,7 @@ template <> void convert_array_storage_impl<void>() {
   BOOST_TEST(!(a == s));
 
   auto c = aref;
-  c.increase(0, s.value(0));
+  c.add(0, s.value(0));
   BOOST_TEST_EQ(c.value(0), 1.0);
   BOOST_TEST(c == s);
   BOOST_TEST(s == c);
@@ -278,9 +279,31 @@ template <> void convert_array_storage_impl<void>() {
 int main() {
   using namespace boost::histogram;
 
+  // low-level tools
+  {
+    uint8_t c = 0;
+    BOOST_TEST_EQ(detail::safe_increase(c), true);
+    BOOST_TEST_EQ(c, 1);
+    c = 255;
+    BOOST_TEST_EQ(detail::safe_increase(c), false);
+    BOOST_TEST_EQ(c, 255);
+    BOOST_TEST_EQ(detail::safe_assign(c, 255), true);
+    BOOST_TEST_EQ(detail::safe_assign(c, 256), false);
+    BOOST_TEST_EQ(c, 255);
+    c = 0;
+    BOOST_TEST_EQ(detail::safe_radd(c, 255), true);
+    BOOST_TEST_EQ(c, 255);
+    c = 1;
+    BOOST_TEST_EQ(detail::safe_radd(c, 255), false);
+    BOOST_TEST_EQ(c, 1);
+    c = 255;
+    BOOST_TEST_EQ(detail::safe_radd(c, 1), false);
+    BOOST_TEST_EQ(c, 255);
+  }
+
   // empty state
   {
-    adaptive_storage<> a;
+    adaptive_storage a;
     BOOST_TEST_EQ(a.size(), 0);
   }
 
@@ -325,18 +348,18 @@ int main() {
 
   // add_and_grow
   {
-    adaptive_storage<> a(1);
+    adaptive_storage a(1);
     a.increase(0);
     double x = 1.0;
-    adaptive_storage<> y(1);
+    adaptive_storage y(1);
     BOOST_TEST_EQ(y.value(0), 0.0);
-    a.increase(0, y.value(0));
+    a.add(0, y.value(0));
     BOOST_TEST_EQ(a.value(0), x);
     for (unsigned i = 0; i < 80; ++i) {
-      a.increase(0, a.value(0));
+      a.add(0, a.value(0));
       x += x;
-      adaptive_storage<> b(1);
-      b.increase(0, a.value(0));
+      adaptive_storage b(1);
+      b.add(0, a.value(0));
       BOOST_TEST_EQ(a.value(0), x);
       BOOST_TEST_EQ(a.variance(0), x);
       BOOST_TEST_EQ(b.value(0), x);
@@ -344,7 +367,7 @@ int main() {
       b.weighted_increase(0, 0.0);
       BOOST_TEST_EQ(b.value(0), x);
       BOOST_TEST_EQ(b.variance(0), x);
-      adaptive_storage<> c(1);
+      adaptive_storage c(1);
       c.weighted_increase(0, a.value(0));
       BOOST_TEST_EQ(c.value(0), x);
       BOOST_TEST_EQ(c.variance(0), x * x);
diff --git a/test/array_storage_test.cpp b/test/array_storage_test.cpp
index 00aa46f1..4a86b30a 100644
--- a/test/array_storage_test.cpp
+++ b/test/array_storage_test.cpp
@@ -35,7 +35,7 @@ int main() {
     c.increase(0);
     c.increase(0);
     d.increase(0);
-    d.increase(1, 5);
+    d.add(1, 5);
     BOOST_TEST_EQ(a.value(0), 1u);
     BOOST_TEST_EQ(b.value(0), 1u);
     BOOST_TEST_EQ(c.value(0), 2u);
diff --git a/test/histogram_test.cpp b/test/histogram_test.cpp
index e63cbba5..fda71217 100644
--- a/test/histogram_test.cpp
+++ b/test/histogram_test.cpp
@@ -50,21 +50,21 @@ template <typename Type> void run_tests() {
   // init_0
   {
     auto h =
-        histogram<Static, mpl::vector<axis::integer<>>, adaptive_storage<>>();
+        histogram<Static, mpl::vector<axis::integer<>>, adaptive_storage>();
     BOOST_TEST_EQ(h.dim(), 1);
     BOOST_TEST_EQ(h.size(), 0);
     auto h2 = histogram<Static, mpl::vector<axis::integer<>>,
                         array_storage<unsigned>>();
     BOOST_TEST(h2 == h);
     auto h3 =
-        histogram<Static, mpl::vector<axis::regular<>>, adaptive_storage<>>();
+        histogram<Static, mpl::vector<axis::regular<>>, adaptive_storage>();
     BOOST_TEST(h3 != h);
   }
 
   // init_1
   {
     auto h =
-        make_histogram<adaptive_storage<>>(Type(), axis::regular<>{3, -1, 1});
+        make_histogram<adaptive_storage>(Type(), axis::regular<>{3, -1, 1});
     BOOST_TEST_EQ(h.dim(), 1);
     BOOST_TEST_EQ(h.size(), 5);
     BOOST_TEST_EQ(shape(h.axis(0_c)), 5);
@@ -76,7 +76,7 @@ template <typename Type> void run_tests() {
 
   // init_2
   {
-    auto h = make_histogram<adaptive_storage<>>(
+    auto h = make_histogram<adaptive_storage>(
         Type(), axis::regular<>{3, -1, 1}, axis::integer<>{-1, 2});
     BOOST_TEST_EQ(h.dim(), 2);
     BOOST_TEST_EQ(h.size(), 25);
@@ -89,7 +89,7 @@ template <typename Type> void run_tests() {
 
   // init_3
   {
-    auto h = make_histogram<adaptive_storage<>>(
+    auto h = make_histogram<adaptive_storage>(
         Type(), axis::regular<>{3, -1, 1}, axis::integer<>{-1, 2},
         axis::circular<>{3});
     BOOST_TEST_EQ(h.dim(), 3);
@@ -102,7 +102,7 @@ template <typename Type> void run_tests() {
 
   // init_4
   {
-    auto h = make_histogram<adaptive_storage<>>(
+    auto h = make_histogram<adaptive_storage>(
         Type(), axis::regular<>{3, -1, 1}, axis::integer<>{-1, 2},
         axis::circular<>{3}, axis::variable<>{-1, 0, 1});
     BOOST_TEST_EQ(h.dim(), 4);
@@ -116,7 +116,7 @@ template <typename Type> void run_tests() {
   // init_5
   {
     enum { A, B, C };
-    auto h = make_histogram<adaptive_storage<>>(
+    auto h = make_histogram<adaptive_storage>(
         Type(), axis::regular<>{3, -1, 1}, axis::integer<>{-1, 2},
         axis::circular<>{3}, axis::variable<>{-1, 0, 1},
         axis::category<>{{A, B, C}});
@@ -131,7 +131,7 @@ template <typename Type> void run_tests() {
 
   // copy_ctor
   {
-    auto h = make_histogram<adaptive_storage<>>(Type(), axis::integer<>{0, 2},
+    auto h = make_histogram<adaptive_storage>(Type(), axis::integer<>{0, 2},
                                                 axis::integer<>{0, 3});
     h.fill(0, 0);
     auto h2 = decltype(h)(h);
@@ -143,7 +143,7 @@ template <typename Type> void run_tests() {
 
   // copy_assign
   {
-    auto h = make_histogram<adaptive_storage<>>(Type(), axis::integer<>(0, 1),
+    auto h = make_histogram<adaptive_storage>(Type(), axis::integer<>(0, 1),
                                                 axis::integer<>(0, 2));
     h.fill(0, 0);
     auto h2 = decltype(h)();
@@ -161,7 +161,7 @@ template <typename Type> void run_tests() {
 
   // move
   {
-    auto h = make_histogram<adaptive_storage<>>(Type(), axis::integer<>(0, 1),
+    auto h = make_histogram<adaptive_storage>(Type(), axis::integer<>(0, 1),
                                                 axis::integer<>(0, 2));
     h.fill(0, 0);
     const auto href = h;
@@ -183,14 +183,14 @@ template <typename Type> void run_tests() {
   // utility
   {
     auto a =
-        make_histogram<adaptive_storage<>>(Type(), axis::regular<>(1, 1, 2));
+        make_histogram<adaptive_storage>(Type(), axis::regular<>(1, 1, 2));
     BOOST_TEST_EQ(size(a.axis()), 1);
     BOOST_TEST_EQ(shape(a.axis()), 3);
     BOOST_TEST_EQ(index(a.axis(), 1.0), 0);
     BOOST_TEST_EQ(bin(a.axis(), 0).lower(), 1.0);
     BOOST_TEST_EQ(bin(a.axis(), 0).upper(), 2.0);
 
-    auto b = make_histogram<adaptive_storage<>>(Type(), axis::integer<>(1, 2));
+    auto b = make_histogram<adaptive_storage>(Type(), axis::integer<>(1, 2));
     BOOST_TEST_EQ(size(a.axis()), 1);
     BOOST_TEST_EQ(shape(a.axis()), 3);
     BOOST_TEST_EQ(index(a.axis(), 1.0), 0);
@@ -200,18 +200,18 @@ template <typename Type> void run_tests() {
 
   // equal_compare
   {
-    auto a = make_histogram<adaptive_storage<>>(Type(), axis::integer<>(0, 2));
-    auto b = make_histogram<adaptive_storage<>>(Type(), axis::integer<>(0, 2),
+    auto a = make_histogram<adaptive_storage>(Type(), axis::integer<>(0, 2));
+    auto b = make_histogram<adaptive_storage>(Type(), axis::integer<>(0, 2),
                                                 axis::integer<>(0, 3));
     BOOST_TEST(a != b);
     BOOST_TEST(b != a);
-    auto c = make_histogram<adaptive_storage<>>(Type(), axis::integer<>(0, 2));
+    auto c = make_histogram<adaptive_storage>(Type(), axis::integer<>(0, 2));
     BOOST_TEST(b != c);
     BOOST_TEST(c != b);
     BOOST_TEST(a == c);
     BOOST_TEST(c == a);
     auto d =
-        make_histogram<adaptive_storage<>>(Type(), axis::regular<>(2, 0, 1));
+        make_histogram<adaptive_storage>(Type(), axis::regular<>(2, 0, 1));
     BOOST_TEST(c != d);
     BOOST_TEST(d != c);
     c.fill(0);
@@ -227,7 +227,7 @@ template <typename Type> void run_tests() {
 
   // d1
   {
-    auto h = make_histogram<adaptive_storage<>>(Type(), axis::integer<>{0, 2});
+    auto h = make_histogram<adaptive_storage>(Type(), axis::integer<>{0, 2});
     h.fill(0);
     h.fill(0);
     h.fill(-1);
@@ -255,7 +255,7 @@ template <typename Type> void run_tests() {
 
   // d1_2
   {
-    auto h = make_histogram<adaptive_storage<>>(
+    auto h = make_histogram<adaptive_storage>(
         Type(), axis::integer<>(0, 2, "", axis::uoflow::off));
     h.fill(0);
     h.fill(-0);
@@ -281,7 +281,7 @@ template <typename Type> void run_tests() {
   // d1w
   {
     auto h =
-        make_histogram<adaptive_storage<>>(Type(), axis::regular<>(2, -1, 1));
+        make_histogram<adaptive_storage>(Type(), axis::regular<>(2, -1, 1));
     h.fill(0);
     h.fill(weight(2.0), -1.0);
     h.fill(-1.0);
@@ -321,7 +321,7 @@ template <typename Type> void run_tests() {
 
   // d2
   {
-    auto h = make_histogram<adaptive_storage<>>(
+    auto h = make_histogram<adaptive_storage>(
         Type(), axis::regular<>(2, -1, 1),
         axis::integer<>(-1, 2, "", axis::uoflow::off));
     h.fill(-1, -1);
@@ -371,7 +371,7 @@ template <typename Type> void run_tests() {
 
   // d2w
   {
-    auto h = make_histogram<adaptive_storage<>>(
+    auto h = make_histogram<adaptive_storage>(
         Type(), axis::regular<>(2, -1, 1),
         axis::integer<>(-1, 2, "", axis::uoflow::off));
     h.fill(-1, 0);              // -> 0, 1
@@ -416,7 +416,7 @@ template <typename Type> void run_tests() {
 
   // d3w
   {
-    auto h = make_histogram<adaptive_storage<>>(Type(), axis::integer<>(0, 3),
+    auto h = make_histogram<adaptive_storage>(Type(), axis::integer<>(0, 3),
                                                 axis::integer<>(0, 4),
                                                 axis::integer<>(0, 5));
     for (auto i = 0; i < size(h.axis(0_c)); ++i) {
@@ -438,7 +438,7 @@ template <typename Type> void run_tests() {
 
   // add_1
   {
-    auto a = make_histogram<adaptive_storage<>>(Type(), axis::integer<>(-1, 2));
+    auto a = make_histogram<adaptive_storage>(Type(), axis::integer<>(-1, 2));
     auto b =
         make_histogram<array_storage<unsigned>>(Type(), axis::integer<>(-1, 2));
     a.fill(-1);
@@ -461,8 +461,8 @@ template <typename Type> void run_tests() {
 
   // add_2
   {
-    auto a = make_histogram<adaptive_storage<>>(Type(), axis::integer<>(0, 2));
-    auto b = make_histogram<adaptive_storage<>>(Type(), axis::integer<>(0, 2));
+    auto a = make_histogram<adaptive_storage>(Type(), axis::integer<>(0, 2));
+    auto b = make_histogram<adaptive_storage>(Type(), axis::integer<>(0, 2));
 
     a.fill(0);
     BOOST_TEST_EQ(a.variance(0), 1);
@@ -512,14 +512,14 @@ template <typename Type> void run_tests() {
 
   // bad_add
   {
-    auto a = make_histogram<adaptive_storage<>>(Type(), axis::integer<>(0, 2));
-    auto b = make_histogram<adaptive_storage<>>(Type(), axis::integer<>(0, 3));
+    auto a = make_histogram<adaptive_storage>(Type(), axis::integer<>(0, 2));
+    auto b = make_histogram<adaptive_storage>(Type(), axis::integer<>(0, 3));
     BOOST_TEST_THROWS(a += b, std::logic_error);
   }
 
   // bad_index
   {
-    auto a = make_histogram<adaptive_storage<>>(Type(), axis::integer<>(0, 2));
+    auto a = make_histogram<adaptive_storage>(Type(), axis::integer<>(0, 2));
     BOOST_TEST_THROWS(a.value(5), std::out_of_range);
     BOOST_TEST_THROWS(a.variance(5), std::out_of_range);
   }
@@ -527,7 +527,7 @@ template <typename Type> void run_tests() {
   // functional programming
   {
     auto v = std::vector<int>{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-    auto h = make_histogram<adaptive_storage<>>(Type(), axis::integer<>(0, 10));
+    auto h = make_histogram<adaptive_storage>(Type(), axis::integer<>(0, 10));
     std::for_each(v.begin(), v.end(), [&h](int x) { h.fill(weight(2.0), x); });
     BOOST_TEST_EQ(h.sum(), 20.0);
   }
@@ -535,7 +535,7 @@ template <typename Type> void run_tests() {
   // histogram_serialization
   {
     enum { A, B, C };
-    auto a = make_histogram<adaptive_storage<>>(
+    auto a = make_histogram<adaptive_storage>(
         Type(), axis::regular<>(3, -1, 1, "r"),
         axis::circular<>(4, 0.0, 1.0, "p"),
         axis::regular<double, axis::transform::log>(3, 1, 100, "lr"),
@@ -561,7 +561,7 @@ template <typename Type> void run_tests() {
 
   // histogram_ostream
   {
-    auto a = make_histogram<adaptive_storage<>>(
+    auto a = make_histogram<adaptive_storage>(
         Type(), axis::regular<>(3, -1, 1, "r"), axis::integer<>(0, 2, "i"));
     std::ostringstream os;
     os << a;
@@ -573,7 +573,7 @@ template <typename Type> void run_tests() {
 
   // histogram_reset
   {
-    auto a = make_histogram<adaptive_storage<>>(
+    auto a = make_histogram<adaptive_storage>(
         Type(), axis::integer<>(0, 2, "", axis::uoflow::off));
     a.fill(0);
     a.fill(1);
@@ -586,7 +586,7 @@ template <typename Type> void run_tests() {
 
   // reduce
   {
-    auto h1 = make_histogram<adaptive_storage<>>(Type(), axis::integer<>(0, 2),
+    auto h1 = make_histogram<adaptive_storage>(Type(), axis::integer<>(0, 2),
                                                  axis::integer<>(0, 3));
     h1.fill(0, 0);
     h1.fill(0, 1);
@@ -611,7 +611,7 @@ template <typename Type> void run_tests() {
     BOOST_TEST_EQ(h1_1.value(2), 1);
     BOOST_TEST(axis_equal(Type(), h1_1.axis(), h1.axis(1_c)));
 
-    auto h2 = make_histogram<adaptive_storage<>>(Type(), axis::integer<>(0, 2),
+    auto h2 = make_histogram<adaptive_storage>(Type(), axis::integer<>(0, 2),
                                                  axis::integer<>(0, 3),
                                                  axis::integer<>(0, 4));
     h2.fill(0, 0, 0);
@@ -677,24 +677,24 @@ template <typename T1, typename T2> void run_mixed_tests() {
 
   // compare
   {
-    auto a = make_histogram<adaptive_storage<>>(T1{}, axis::regular<>{3, 0, 3},
+    auto a = make_histogram<adaptive_storage>(T1{}, axis::regular<>{3, 0, 3},
                                                 axis::integer<>(0, 2));
-    auto b = make_histogram<adaptive_storage<>>(T2{}, axis::regular<>{3, 0, 3},
+    auto b = make_histogram<adaptive_storage>(T2{}, axis::regular<>{3, 0, 3},
                                                 axis::integer<>(0, 2));
     BOOST_TEST_EQ(a, b);
-    auto b2 = make_histogram<adaptive_storage<>>(T2{}, axis::integer<>{0, 3},
+    auto b2 = make_histogram<adaptive_storage>(T2{}, axis::integer<>{0, 3},
                                                  axis::integer<>(0, 2));
     BOOST_TEST_NE(a, b2);
-    auto b3 = make_histogram<adaptive_storage<>>(T2{}, axis::regular<>(3, 0, 4),
+    auto b3 = make_histogram<adaptive_storage>(T2{}, axis::regular<>(3, 0, 4),
                                                  axis::integer<>(0, 2));
     BOOST_TEST_NE(a, b3);
   }
 
   // copy_assign
   {
-    auto a = make_histogram<adaptive_storage<>>(T1{}, axis::regular<>{3, 0, 3},
+    auto a = make_histogram<adaptive_storage>(T1{}, axis::regular<>{3, 0, 3},
                                                 axis::integer<>(0, 2));
-    auto b = make_histogram<adaptive_storage<>>(T2{}, axis::regular<>{3, 0, 3},
+    auto b = make_histogram<adaptive_storage>(T2{}, axis::regular<>{3, 0, 3},
                                                 axis::integer<>(0, 2));
     a.fill(1, 1);
     BOOST_TEST_NE(a, b);
diff --git a/test/python_suite_test.py b/test/python_suite_test.py
index f832076a..dbd046e2 100644
--- a/test/python_suite_test.py
+++ b/test/python_suite_test.py
@@ -778,7 +778,8 @@ class test_histogram(unittest.TestCase):
     def test_fill_with_numpy_array_0(self):
         ar = lambda *args: numpy.array(args, dtype=float)
         a = histogram(integer(0, 3, uoflow=False))
-        a.fill(ar(-1, 0, 1, 2, 1, 4, -1, 0, 1, 2))
+        a.fill(ar(-1, 0, 1, 2, 1))
+        a.fill((4, -1, 0, 1, 2))
         self.assertEqual(a.value(0), 2)
         self.assertEqual(a.value(1), 3)
         self.assertEqual(a.value(2), 2)
@@ -787,7 +788,7 @@ class test_histogram(unittest.TestCase):
             a.fill(numpy.empty((2, 2)))
         with self.assertRaises(ValueError):
             a.fill(numpy.empty(2), 1)
-        with self.assertRaises(TypeError):
+        with self.assertRaises(ValueError):
             a.fill("abc")
 
         a = histogram(integer(0, 2, uoflow=False),
@@ -816,7 +817,7 @@ class test_histogram(unittest.TestCase):
         v = ar(-1, 0, 1, 2, 3, 4)
         w = ar( 2, 3, 4, 5, 6, 7)
         a.fill(v, weight=w)
-        a.fill(ar(0, 1), weight=ar(2, 3))
+        a.fill((0, 1), weight=(2, 3))
         self.assertEqual(a.value(-1), 2)
         self.assertEqual(a.value(0), 5)
         self.assertEqual(a.value(1), 7)
@@ -825,32 +826,33 @@ class test_histogram(unittest.TestCase):
         self.assertEqual(a.variance(0), 13)
         self.assertEqual(a.variance(1), 25)
         self.assertEqual(a.variance(2), 25)
-        a.fill(ar(1, 2), weight=1)
-        a.fill(0, weight=ar(1, 2))
+        a.fill((1, 2), weight=1)
+        a.fill(0, weight=(1, 2))
         self.assertEqual(a.value(0), 8)
         self.assertEqual(a.value(1), 8)
         self.assertEqual(a.value(2), 6)
 
         with self.assertRaises(RuntimeError):
-            a.fill(ar(1, 2), foo=ar(1, 1))
+            a.fill((1, 2), foo=(1, 1))
         with self.assertRaises(ValueError):
-            a.fill(ar(1, 2), weight=ar(1))
-        with self.assertRaises(TypeError):
-            a.fill(ar(1, 2), weight="ab")
+            a.fill((1, 2), weight=(1,))
+        with self.assertRaises(ValueError):
+            a.fill((1, 2), weight="ab")
         with self.assertRaises(RuntimeError):
-            a.fill(ar(1, 2), weight=ar(1, 1), foo=1)
+            a.fill((1, 2), weight=(1, 1), foo=1)
         with self.assertRaises(ValueError):
-            a.fill(ar(1, 2), weight=ar([1, 1], [2, 2]))
+            a.fill((1, 2), weight=([1, 1], [2, 2]))
 
         a = histogram(integer(0, 2, uoflow=False),
                       regular(2, 0, 2, uoflow=False))
-        a.fill(ar(-1, 0, 1), ar(-1, 1, 0.1))
+        a.fill((-1, 0, 1), (-1, 1, 0.1))
         self.assertEqual(a.value(0, 0), 0)
         self.assertEqual(a.value(0, 1), 1)
         self.assertEqual(a.value(1, 0), 1)
         self.assertEqual(a.value(1, 1), 0)
         a = histogram(integer(0, 3, uoflow=False))
-        a.fill(ar(0, 0, 1, 2, 1, 0, 2, 2))
+        a.fill((0, 0, 1, 2))
+        a.fill((1, 0, 2, 2))
         self.assertEqual(a.value(0), 3)
         self.assertEqual(a.value(1), 2)
         self.assertEqual(a.value(2), 3)
diff --git a/test/speed_cpp.cpp b/test/speed_cpp.cpp
index 2c15ff4f..43f73cdc 100644
--- a/test/speed_cpp.cpp
+++ b/test/speed_cpp.cpp
@@ -113,13 +113,13 @@ int main() {
                6000000, itype));
     printf("hs_sd %.3f\n",
            compare_1d<histogram<Static,mpl::vector<axis::regular<>>,
-                                adaptive_storage<>>>(6000000, itype));
+                                adaptive_storage>>(6000000, itype));
     printf("hd_ss %.3f\n",
            compare_1d<histogram<Dynamic, builtin_axes,
                                 array_storage<int>>>(
                6000000, itype));
     printf("hd_sd %.3f\n",
-           compare_1d<histogram<Dynamic, builtin_axes, adaptive_storage<>>>(
+           compare_1d<histogram<Dynamic, builtin_axes, adaptive_storage>>(
                6000000, itype));
   }
 
@@ -136,13 +136,13 @@ int main() {
     printf("hs_sd %.3f\n",
            compare_2d<histogram<Static,
                mpl::vector<axis::regular<>, axis::regular<>>,
-               adaptive_storage<>>>(6000000, itype));
+               adaptive_storage>>(6000000, itype));
     printf("hd_ss %.3f\n",
            compare_2d<histogram<Dynamic, builtin_axes,
                       array_storage<int>>>(
                6000000, itype));
     printf("hd_sd %.3f\n",
-           compare_2d<histogram<Dynamic, builtin_axes, adaptive_storage<>>>(
+           compare_2d<histogram<Dynamic, builtin_axes, adaptive_storage>>(
                6000000, itype));
   }
 
@@ -159,13 +159,13 @@ int main() {
     printf("hs_sd %.3f\n",
            compare_3d<histogram<Static,
                mpl::vector<axis::regular<>, axis::regular<>, axis::regular<>>,
-               adaptive_storage<>>>(6000000, itype));
+               adaptive_storage>>(6000000, itype));
     printf("hd_ss %.3f\n",
            compare_3d<histogram<Dynamic, builtin_axes,
                                 array_storage<int>>>(
                6000000, itype));
     printf("hd_sd %.3f\n",
-           compare_3d<histogram<Dynamic, builtin_axes, adaptive_storage<>>>(
+           compare_3d<histogram<Dynamic, builtin_axes, adaptive_storage>>(
                6000000, itype));
   }
 
@@ -184,13 +184,13 @@ int main() {
            compare_6d<histogram<Static,
                mpl::vector<axis::regular<>, axis::regular<>, axis::regular<>,
                            axis::regular<>, axis::regular<>, axis::regular<>>,
-               adaptive_storage<>>>(6000000, itype));
+               adaptive_storage>>(6000000, itype));
     printf("hd_ss %.3f\n",
            compare_6d<histogram<Dynamic, builtin_axes,
                                 array_storage<int>>>(
                6000000, itype));
     printf("hd_sd %.3f\n",
-           compare_6d<histogram<Dynamic, builtin_axes, adaptive_storage<>>>(
+           compare_6d<histogram<Dynamic, builtin_axes, adaptive_storage>>(
                6000000, itype));
   }
 }